From 5318489b87fa068633fcf437dc8274508b96f654 Mon Sep 17 00:00:00 2001
From: joonhaengHeo <85541460+joonhaengHeo@users.noreply.github.com>
Date: Wed, 8 Nov 2023 10:29:50 +0900
Subject: [PATCH] [Android] Remove JNI code in each cluster. (#30141)

* Remove Java ChipClusters readAttribute jni

* Implement write, subscribe, invoke

* Implement Struct TLV parinsg

* Fix write, invoke crash

* Remove native method, fix empty command response issue

* Remove android controller data model code

* Attribute ID change to private static variable.

* Restyled by whitespace

* Restyled by google-java-format

* Restyled by clang-format

* Restyled by autopep8

* Use ChipDeviceController API

* Replace List.of -> Arrays.asList

---------

Co-authored-by: Restyled.io <commits@restyled.io>
---
 .../clusterclient/GroupSettingFragment.kt     |   251 +-
 .../generators/java/ChipClusters_java.jinja   |   421 +-
 .../java/ChipEventStructs_java.jinja          |    95 +
 .../generators/java/ChipStructs_java.jinja    |    95 +
 .../matter_idl/generators/java/__init__.py    |    31 +
 .../several_clusters/java/ChipClusters.java   |   403 +-
 .../java/ChipEventStructs.java                |     2 +
 .../several_clusters/java/ChipStructs.java    |    74 +
 src/controller/java/BUILD.gn                  |    17 +-
 src/controller/java/BaseCHIPCluster-JNI.cpp   |   394 +-
 .../java/CHIPDeviceController-JNI.cpp         |     8 +-
 .../chip/devicecontroller/ChipClusters.java   | 52442 +++++++++++-----
 .../devicecontroller/ChipEventStructs.java    |  2018 +
 .../chip/devicecontroller/ChipStructs.java    |  4196 ++
 .../ChipDeviceController.java                 |     8 +-
 .../chip/devicecontroller/ChipTLVType.java    |   366 +
 16 files changed, 45674 insertions(+), 15147 deletions(-)
 create mode 100644 src/controller/java/src/chip/devicecontroller/ChipTLVType.java

diff --git a/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/GroupSettingFragment.kt b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/GroupSettingFragment.kt
index 9687237a814e0d..8943801c080c80 100644
--- a/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/GroupSettingFragment.kt
+++ b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/GroupSettingFragment.kt
@@ -12,19 +12,12 @@ import android.widget.EditText
 import android.widget.Spinner
 import androidx.fragment.app.Fragment
 import androidx.lifecycle.lifecycleScope
+import chip.devicecontroller.ChipClusters
 import chip.devicecontroller.ChipDeviceController
-import chip.devicecontroller.ClusterIDMapping
+import chip.devicecontroller.ChipStructs
+import chip.devicecontroller.ChipStructs.AccessControlClusterAccessControlEntryStruct
+import chip.devicecontroller.ChipStructs.GroupKeyManagementClusterGroupKeySetStruct
 import chip.devicecontroller.GroupKeySecurityPolicy
-import chip.devicecontroller.InvokeCallback
-import chip.devicecontroller.ReportCallback
-import chip.devicecontroller.WriteAttributesCallback
-import chip.devicecontroller.cluster.structs.AccessControlClusterAccessControlEntryStruct
-import chip.devicecontroller.cluster.structs.GroupKeyManagementClusterGroupKeySetStruct
-import chip.devicecontroller.model.AttributeWriteRequest
-import chip.devicecontroller.model.ChipAttributePath
-import chip.devicecontroller.model.ChipEventPath
-import chip.devicecontroller.model.InvokeElement
-import chip.devicecontroller.model.NodeState
 import com.google.chip.chiptool.ChipClient
 import com.google.chip.chiptool.GenericChipDeviceListener
 import com.google.chip.chiptool.R
@@ -33,10 +26,6 @@ import com.google.chip.chiptool.util.DeviceIdUtil
 import java.lang.Exception
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
-import matter.tlv.AnonymousTag
-import matter.tlv.ContextSpecificTag
-import matter.tlv.TlvReader
-import matter.tlv.TlvWriter
 
 class GroupSettingFragment : Fragment() {
   private val deviceController: ChipDeviceController
@@ -260,14 +249,17 @@ class GroupSettingFragment : Fragment() {
       scope.launch {
         val keySetWritestruct =
           GroupKeyManagementClusterGroupKeySetStruct(
-            keySetIdEd.text.toString().toUInt(),
-            GroupKeySecurityPolicy.valueOf(keySecurityPolicySp.selectedItem.toString()).id.toUInt(),
+            keySetIdEd.text.toString().toUInt().toInt(),
+            GroupKeySecurityPolicy.valueOf(keySecurityPolicySp.selectedItem.toString())
+              .id
+              .toUInt()
+              .toInt(),
             hexStringToByteArray(epochKey0Ed.text.toString()),
-            epochStartTime0Ed.text.toString().toULong(),
+            epochStartTime0Ed.text.toString().toULong().toLong(),
             hexStringToByteArray(epochKey1Ed.text.toString()),
-            epochStartTime1Ed.text.toString().toULong(),
+            epochStartTime1Ed.text.toString().toULong().toLong(),
             hexStringToByteArray(epochKey2Ed.text.toString()),
-            epochStartTime2Ed.text.toString().toULong()
+            epochStartTime2Ed.text.toString().toULong().toLong()
           )
         sendKeySetWrite(keySetWritestruct)
         requireActivity().runOnUiThread { dialog.dismiss() }
@@ -279,41 +271,24 @@ class GroupSettingFragment : Fragment() {
   private suspend fun sendKeySetWrite(
     groupKeySetStruct: GroupKeyManagementClusterGroupKeySetStruct
   ) {
-    val tlvWriter =
-      TlvWriter()
-        .startStructure(AnonymousTag)
-        .apply {
-          groupKeySetStruct.toTlv(
-            ContextSpecificTag(
-              ClusterIDMapping.GroupKeyManagement.KeySetWriteCommandField.GroupKeySet.id
-            ),
-            this
-          )
-        }
-        .endStructure()
-
-    deviceController.invoke(
-      object : InvokeCallback {
-        override fun onError(e: java.lang.Exception?) {
+    val cluster =
+      ChipClusters.GroupKeyManagementCluster(
+        ChipClient.getConnectedDevicePointer(requireContext(), addressUpdateFragment.deviceId),
+        0
+      )
+    cluster.keySetWrite(
+      object : ChipClusters.DefaultClusterCallback {
+        override fun onError(e: Exception?) {
           Log.d(TAG, "onError : ", e)
           showMessage("onError : ${e.toString()}")
         }
 
-        override fun onResponse(invokeElement: InvokeElement?, successCode: Long) {
+        override fun onSuccess() {
           Log.d(TAG, "onResponse")
-          showMessage("onResponse : $successCode")
+          showMessage("onResponse")
         }
       },
-      ChipClient.getConnectedDevicePointer(requireContext(), addressUpdateFragment.deviceId),
-      InvokeElement.newInstance(
-        0,
-        ClusterIDMapping.GroupKeyManagement.ID,
-        ClusterIDMapping.GroupKeyManagement.Command.KeySetWrite.id,
-        tlvWriter.getEncoded(),
-        null
-      ),
-      0,
-      0
+      groupKeySetStruct
     )
   }
 
@@ -336,39 +311,30 @@ class GroupSettingFragment : Fragment() {
   }
 
   private suspend fun writeGroupKeyMap(groupId: UInt, groupKeySetId: UInt) {
-    val tlvWriter =
-      TlvWriter().apply {
-        startArray(AnonymousTag)
-        startStructure(AnonymousTag)
-        put(ContextSpecificTag(1), groupId)
-        put(ContextSpecificTag(2), groupKeySetId)
-        endStructure()
-        endArray()
-      }
-
-    deviceController.write(
-      object : WriteAttributesCallback {
-        override fun onError(attributePath: ChipAttributePath?, e: Exception?) {
+    val cluster =
+      ChipClusters.GroupKeyManagementCluster(
+        ChipClient.getConnectedDevicePointer(requireContext(), addressUpdateFragment.deviceId),
+        0
+      )
+    cluster.writeGroupKeyMapAttribute(
+      object : ChipClusters.DefaultClusterCallback {
+        override fun onError(e: Exception?) {
           Log.d(TAG, "onError : ", e)
           showMessage("Error : ${e.toString()}")
         }
 
-        override fun onResponse(attributePath: ChipAttributePath?) {
+        override fun onSuccess() {
           Log.d(TAG, "onResponse")
           showMessage("write Success")
         }
       },
-      ChipClient.getConnectedDevicePointer(requireContext(), addressUpdateFragment.deviceId),
-      listOf(
-        AttributeWriteRequest.newInstance(
-          0,
-          ClusterIDMapping.GroupKeyManagement.ID,
-          ClusterIDMapping.GroupKeyManagement.Attribute.GroupKeyMap.id,
-          tlvWriter.getEncoded()
+      arrayListOf(
+        ChipStructs.GroupKeyManagementClusterGroupKeyMapStruct(
+          groupId.toInt(),
+          groupKeySetId.toInt(),
+          deviceController.fabricIndex
         )
-      ),
-      0,
-      0
+      )
     )
   }
 
@@ -390,75 +356,52 @@ class GroupSettingFragment : Fragment() {
   }
 
   private suspend fun sendAddGroup(groupId: UInt, groupName: String) {
-    val tlvWriter =
-      TlvWriter().apply {
-        startStructure(AnonymousTag)
-        put(ContextSpecificTag(0), groupId)
-        put(ContextSpecificTag(1), groupName)
-        endStructure()
-      }
-
-    deviceController.invoke(
-      object : InvokeCallback {
+    val cluster =
+      ChipClusters.GroupsCluster(
+        ChipClient.getConnectedDevicePointer(requireContext(), addressUpdateFragment.deviceId),
+        0
+      )
+    cluster.addGroup(
+      object : ChipClusters.GroupsCluster.AddGroupResponseCallback {
         override fun onError(e: Exception?) {
           Log.d(TAG, "onError : ", e)
           showMessage("Error : ${e.toString()}")
         }
 
-        override fun onResponse(invokeElement: InvokeElement?, successCode: Long) {
+        override fun onSuccess(status: Int?, groupID: Int?) {
           Log.d(TAG, "onResponse")
-          showMessage("onResponse : $successCode")
+          showMessage("onResponse : $status, $groupID")
         }
       },
-      ChipClient.getConnectedDevicePointer(requireContext(), addressUpdateFragment.deviceId),
-      InvokeElement.newInstance(
-        0,
-        ClusterIDMapping.Groups.ID,
-        ClusterIDMapping.Groups.Command.AddGroup.id,
-        tlvWriter.getEncoded(),
-        null
-      ),
-      0,
-      0
+      groupId.toInt(),
+      groupName
     )
   }
 
   private suspend fun readAccessControl() {
-    val endpointId = 0
-    val clusterId = ClusterIDMapping.AccessControl.ID
-    val attributeId = ClusterIDMapping.AccessControl.Attribute.Acl.id
-
-    val attributePath = ChipAttributePath.newInstance(endpointId, clusterId, attributeId)
-    deviceController.readAttributePath(
-      object : ReportCallback {
-        override fun onError(
-          attributePath: ChipAttributePath?,
-          eventPath: ChipEventPath?,
-          e: Exception
-        ) {
+    val cluster =
+      ChipClusters.AccessControlCluster(
+        ChipClient.getConnectedDevicePointer(requireContext(), addressUpdateFragment.deviceId),
+        0
+      )
+    cluster.readAclAttribute(
+      object : ChipClusters.AccessControlCluster.AclAttributeCallback {
+        override fun onError(e: Exception?) {
           Log.d(TAG, "onError : ", e)
           showMessage("Error : $e")
         }
 
-        override fun onReport(nodeState: NodeState?) {
-          Log.d(TAG, "onResponse")
-          val tlv =
-            nodeState
-              ?.getEndpointState(endpointId)
-              ?.getClusterState(clusterId)
-              ?.getAttributeState(attributeId)
-              ?.tlv
-          requireActivity().runOnUiThread { showAddAccessControlDialog(tlv) }
+        override fun onSuccess(value: MutableList<AccessControlClusterAccessControlEntryStruct>?) {
+          requireActivity().runOnUiThread { showAddAccessControlDialog(value) }
         }
-      },
-      ChipClient.getConnectedDevicePointer(requireContext(), addressUpdateFragment.deviceId),
-      listOf(attributePath),
-      0
+      }
     )
   }
 
-  private fun showAddAccessControlDialog(tlv: ByteArray?) {
-    if (tlv == null) {
+  private fun showAddAccessControlDialog(
+    value: List<AccessControlClusterAccessControlEntryStruct>?
+  ) {
+    if (value == null) {
       Log.d(TAG, "Access Control read fail")
       showMessage("Access Control read fail")
       return
@@ -479,7 +422,7 @@ class GroupSettingFragment : Fragment() {
     dialogView.findViewById<Button>(R.id.addAccessControlBtn).setOnClickListener {
       scope.launch {
         sendAccessControl(
-          tlv,
+          value,
           groupIdEd.text.toString().toUInt(),
           AccessControlEntry.valueOf(accessControlEntrySp.selectedItem.toString()).id
         )
@@ -489,66 +432,52 @@ class GroupSettingFragment : Fragment() {
     dialog.show()
   }
 
-  private suspend fun sendAccessControl(tlv: ByteArray, groupId: UInt, privilege: UInt) {
-    val tlvWriter = TlvWriter().startArray(AnonymousTag)
-    var entryStructList: List<AccessControlClusterAccessControlEntryStruct>
-    TlvReader(tlv).also {
-      entryStructList = buildList {
-        it.enterArray(AnonymousTag)
-        while (!it.isEndOfContainer()) {
-          add(AccessControlClusterAccessControlEntryStruct.fromTlv(AnonymousTag, it))
-        }
-        it.exitContainer()
-      }
-    }
-
+  private suspend fun sendAccessControl(
+    value: List<AccessControlClusterAccessControlEntryStruct>,
+    groupId: UInt,
+    privilege: UInt
+  ) {
     // If GroupID is already added to AccessControl, do not add it.
-    for (entry in entryStructList) {
+    val cluster =
+      ChipClusters.AccessControlCluster(
+        ChipClient.getConnectedDevicePointer(requireContext(), addressUpdateFragment.deviceId),
+        0
+      )
+    val sendEntry = ArrayList<AccessControlClusterAccessControlEntryStruct>()
+    for (entry in value) {
       if (
-        entry.authMode == 3U /* Group */ &&
+        entry.authMode == AccessControlEntry.Operate.id.toInt() /* Group */ &&
           entry.subjects != null &&
-          entry.subjects!!.contains(groupId.toULong())
+          entry.subjects!!.contains(groupId.toULong().toLong())
       ) {
         continue
       }
-
-      entry.toTlv(AnonymousTag, tlvWriter)
+      sendEntry.add(entry)
     }
 
     val newEntry =
       AccessControlClusterAccessControlEntryStruct(
-        privilege,
-        3U /* Group */,
-        listOf(groupId.toULong()),
+        privilege.toInt(),
+        AccessControlEntry.Operate.id.toInt() /* Group */,
+        arrayListOf(groupId.toULong().toLong()),
         null,
-        deviceController.fabricIndex.toUInt()
+        deviceController.fabricIndex.toUInt().toInt()
       )
-    newEntry.toTlv(AnonymousTag, tlvWriter)
-    tlvWriter.endArray()
+    sendEntry.add(newEntry)
 
-    deviceController.write(
-      object : WriteAttributesCallback {
-        override fun onError(attributePath: ChipAttributePath?, e: Exception?) {
+    cluster.writeAclAttribute(
+      object : ChipClusters.DefaultClusterCallback {
+        override fun onError(e: Exception?) {
           Log.d(TAG, "onError : ", e)
           showMessage("Error : ${e.toString()}")
         }
 
-        override fun onResponse(attributePath: ChipAttributePath?) {
+        override fun onSuccess() {
           Log.d(TAG, "onResponse")
           showMessage("write Success")
         }
       },
-      ChipClient.getConnectedDevicePointer(requireContext(), addressUpdateFragment.deviceId),
-      listOf(
-        AttributeWriteRequest.newInstance(
-          0,
-          ClusterIDMapping.AccessControl.ID,
-          ClusterIDMapping.AccessControl.Attribute.Acl.id,
-          tlvWriter.getEncoded()
-        )
-      ),
-      0,
-      0
+      sendEntry
     )
   }
 
diff --git a/scripts/py_matter_idl/matter_idl/generators/java/ChipClusters_java.jinja b/scripts/py_matter_idl/matter_idl/generators/java/ChipClusters_java.jinja
index 1137f582a1a3f9..00d09a51cbed85 100644
--- a/scripts/py_matter_idl/matter_idl/generators/java/ChipClusters_java.jinja
+++ b/scripts/py_matter_idl/matter_idl/generators/java/ChipClusters_java.jinja
@@ -37,6 +37,44 @@
   {%- endif -%}
 {%- endmacro -%}
 
+{%- macro encode_tlv(source, encodable, variable, depth) -%}
+  {%- if encodable.is_nullable -%}
+    {{variable}} != null ? {{encode_tlv(source, encodable.without_nullable(), variable, depth + 1)}} : new NullType()
+  {%- elif encodable.is_optional -%}
+    {{variable}}.<BaseTLVType>map(({{"nonOptional{}".format(variable)}}) -> {{encode_tlv(source, encodable.without_optional(), "nonOptional{}".format(variable), depth + 1)}}).orElse(new EmptyType())
+  {%- elif encodable.is_list -%}
+    ArrayType.generateArrayType({{variable}}, ({{"element{}".format(variable)}}) -> {{encode_tlv(source, encodable.without_list(), "element{}".format(variable), depth + 1)}})
+  {%- elif encodable.is_struct -%}
+    {%- set struct = encodable.get_underlying_struct() -%}
+    {{variable}}.encodeTlv()
+  {%- else -%}
+    new {{encodable.java_tlv_type}}Type({{variable}})
+  {%- endif -%}
+{%- endmacro -%}
+
+{%- macro decode_tlv(source, encodable, variable, depth) -%}
+  {%- if encodable.is_optional -%}
+    Optional.of({{decode_tlv(source, encodable.without_optional(), variable, depth + 1)}})
+  {%- elif encodable.is_list -%}
+    {{variable}}.map(({{"element{}".format(variable)}}) -> {{decode_tlv(source, encodable.without_list(), "element{}".format(variable), depth + 1)}})
+  {%- elif encodable.is_struct -%}
+    {%- set struct = encodable.get_underlying_struct() -%}
+    ChipStructs.{{source.name}}Cluster{{struct.name}}.decodeTlv({{variable}})
+  {%- else -%}
+    {{variable}}.value({{encodable.boxed_java_type}}.class)
+  {%- endif -%}
+{%- endmacro -%}
+
+{%- macro get_tlvType(encodable) -%}
+  {%- if encodable.is_list -%}
+    Array
+  {%- elif encodable.is_struct -%}
+    Struct
+  {%- else -%}
+    {{encodable.java_tlv_type}}
+  {%- endif -%}
+{%- endmacro -%}
+
 /*
  *
  *    Copyright (c) 2023 Project CHIP Authors
@@ -56,68 +94,84 @@
 
 package chip.devicecontroller;
 
+import chip.devicecontroller.model.AttributeState;
+import chip.devicecontroller.model.AttributeWriteRequest;
+import chip.devicecontroller.model.ChipAttributePath;
+import chip.devicecontroller.model.ChipEventPath;
+import chip.devicecontroller.model.ClusterState;
+import chip.devicecontroller.model.EndpointState;
+import chip.devicecontroller.model.InvokeElement;
+import chip.devicecontroller.model.NodeState;
+
 import javax.annotation.Nullable;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Optional;
 
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import static chip.devicecontroller.ChipTLVType.*;
+
 public class ChipClusters {
 
-  public interface DefaultClusterCallback {
+  public interface BaseClusterCallback {
+    void onError(Exception error);
+  }
+
+  public interface DefaultClusterCallback extends BaseClusterCallback {
     void onSuccess();
+  }
+
+  public interface BaseAttributeCallback {
     void onError(Exception error);
+    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
-  public interface CharStringAttributeCallback {
+  public interface CharStringAttributeCallback extends BaseAttributeCallback {
     /** Indicates a successful read for a CHAR_STRING attribute. */
     void onSuccess(String value);
-    void onError(Exception error);
-    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
-  public interface OctetStringAttributeCallback {
+  public interface OctetStringAttributeCallback extends BaseAttributeCallback {
     /** Indicates a successful read for an OCTET_STRING attribute. */
     void onSuccess(byte[] value);
-    void onError(Exception error);
-    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
-  public interface IntegerAttributeCallback {
+  public interface IntegerAttributeCallback extends BaseAttributeCallback {
     void onSuccess(int value);
-    void onError(Exception error);
-    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
-  public interface LongAttributeCallback {
+  public interface LongAttributeCallback extends BaseAttributeCallback {
     void onSuccess(long value);
-    void onError(Exception error);
-    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
-  public interface BooleanAttributeCallback {
+  public interface BooleanAttributeCallback extends BaseAttributeCallback {
     void onSuccess(boolean value);
-    void onError(Exception error);
-    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
-  public interface FloatAttributeCallback {
+  public interface FloatAttributeCallback extends BaseAttributeCallback {
     void onSuccess(float value);
-    void onError(Exception error);
-    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
-  public interface DoubleAttributeCallback {
+  public interface DoubleAttributeCallback extends BaseAttributeCallback {
     void onSuccess(double value);
-    void onError(Exception error);
-    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
   public static abstract class BaseChipCluster {
     protected long chipClusterPtr;
 
-    public BaseChipCluster(long devicePtr, int endpointId) {
-      chipClusterPtr = initWithDevice(devicePtr, endpointId);
+    protected long devicePtr;
+    protected int endpointId;
+    protected long clusterId;
+
+    private Optional<Long> timeoutMillis = Optional.empty();
+
+    public BaseChipCluster(long devicePtr, int endpointId, long clusterId) {
+      this.devicePtr = devicePtr;
+      this.endpointId = endpointId;
+      this.clusterId = clusterId;
     }
 
     /**
@@ -126,22 +180,64 @@ public class ChipClusters {
      * empty optional, the default timeout will be used.
      */
     public void setCommandTimeout(Optional<Long> timeoutMillis) {
-      setCommandTimeout(chipClusterPtr, timeoutMillis);
+      this.timeoutMillis = timeoutMillis;
     }
 
-    private native void setCommandTimeout(long clusterPtr, Optional<Long> timeoutMillis);
-
     /** Returns the current timeout (in milliseconds) for commands sent through this cluster. */
     public Optional<Long> getCommandTimeout() {
-      Optional<Long> timeout = getCommandTimeout(chipClusterPtr);
-      return timeout == null ? Optional.empty() : timeout;
+      return timeoutMillis == null ? Optional.empty() : timeoutMillis;
     }
 
-    private native Optional<Long> getCommandTimeout(long clusterPtr);
-
+    @Deprecated
     public abstract long initWithDevice(long devicePtr, int endpointId);
 
-    public native void deleteCluster(long chipClusterPtr);
+    protected void readAttribute(
+        ReportCallbackImpl callback,
+        long attributeId,
+        boolean isFabricFiltered) {
+      ReportCallbackJni jniCallback = new ReportCallbackJni(null, callback, null);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, attributeId);
+      ChipDeviceController.read(0, jniCallback.getCallbackHandle(), devicePtr, Arrays.asList(path), null, isFabricFiltered, timeoutMillis.orElse(0L).intValue(), null);
+    }
+
+    protected void writeAttribute(
+        WriteAttributesCallbackImpl callback,
+        long attributeId,
+        BaseTLVType value,
+        int timedRequestTimeoutMs) {
+      WriteAttributesCallbackJni jniCallback = new WriteAttributesCallbackJni(callback);
+      byte[] tlv = encodeToTlv(value);
+      AttributeWriteRequest writeRequest = AttributeWriteRequest.newInstance(endpointId, clusterId, attributeId, tlv);
+      ChipDeviceController.write(0, jniCallback.getCallbackHandle(), devicePtr, Arrays.asList(writeRequest), timedRequestTimeoutMs, timeoutMillis.orElse(0L).intValue());
+    }
+
+    protected void subscribeAttribute(
+        ReportCallbackImpl callback,
+        long attributeId,
+        int minInterval,
+        int maxInterval) {
+      ReportCallbackJni jniCallback = new ReportCallbackJni(callback, callback, null);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, attributeId);
+      ChipDeviceController.subscribe(0, jniCallback.getCallbackHandle(), devicePtr, Arrays.asList(path), null, minInterval, maxInterval, false, true, timeoutMillis.orElse(0L).intValue(), null);
+    }
+
+    protected void invoke(
+        InvokeCallbackImpl callback,
+        long commandId,
+        BaseTLVType value,
+        int timedRequestTimeoutMs) {
+      InvokeCallbackJni jniCallback = new InvokeCallbackJni(callback);
+      byte[] tlv = encodeToTlv(value);
+      InvokeElement element = InvokeElement.newInstance(endpointId, clusterId, commandId, tlv, null);
+      ChipDeviceController.invoke(0, jniCallback.getCallbackHandle(), devicePtr, element, timedRequestTimeoutMs, timeoutMillis.orElse(0L).intValue());
+    }
+
+    private static native byte[] encodeToTlv(BaseTLVType value);
+
+    static native BaseTLVType decodeFromTlv(byte[] tlv);
+
+    @Deprecated
+    public void deleteCluster(long chipClusterPtr) {}
     
     @SuppressWarnings("deprecation")
     protected void finalize() throws Throwable {
@@ -153,17 +249,132 @@ public class ChipClusters {
       }
     }
   }
+
+  abstract static class ReportCallbackImpl implements ReportCallback, SubscriptionEstablishedCallback {
+    private BaseAttributeCallback callback;
+    private ChipAttributePath path;
+
+    private static final long CHIP_ERROR_UNSUPPORTED_ATTRIBUTE = 0x86;
+
+    ReportCallbackImpl(BaseAttributeCallback callback, ChipAttributePath path) {
+      this.callback = callback;
+      this.path = path;
+    }
+
+    @Override
+    public void onError(
+        @Nullable ChipAttributePath attributePath,
+        @Nullable ChipEventPath eventPath,
+        @Nonnull Exception e) {
+      callback.onError(e);
+    }
+
+    @Override
+    public void onReport(NodeState nodeState) {
+      if (nodeState == null) {
+        callback.onError(new ChipClusterException());
+        return;
+      }
+
+      EndpointState endpointState = nodeState.getEndpointState((int)path.getEndpointId().getId());
+      if (endpointState == null) {
+        callback.onError(new ChipClusterException(CHIP_ERROR_UNSUPPORTED_ATTRIBUTE));
+        return;
+      }
+
+      ClusterState clusterState = endpointState.getClusterState(path.getClusterId().getId());
+      if (clusterState == null) {
+        callback.onError(new ChipClusterException(CHIP_ERROR_UNSUPPORTED_ATTRIBUTE));
+        return;
+      }
+
+      AttributeState attributeState = clusterState.getAttributeState(path.getAttributeId().getId());
+      if (attributeState == null) {
+        callback.onError(new ChipClusterException(CHIP_ERROR_UNSUPPORTED_ATTRIBUTE));
+        return;
+      }
+
+      byte[] tlv = attributeState.getTlv();
+      if (tlv == null) {
+          callback.onError(new ChipClusterException(CHIP_ERROR_UNSUPPORTED_ATTRIBUTE));
+          return;
+      }
+
+      onSuccess(tlv);
+    }
+
+    @Override
+    public void onSubscriptionEstablished(long subscriptionId) {
+      callback.onSubscriptionEstablished(subscriptionId);
+    }
+
+    public abstract void onSuccess(byte[] tlv);
+  }
+
+  static class WriteAttributesCallbackImpl implements WriteAttributesCallback {
+    private DefaultClusterCallback callback;
+
+    WriteAttributesCallbackImpl(DefaultClusterCallback callback) {
+      this.callback = callback;
+    }
+
+    @Override
+    public void onResponse(ChipAttributePath attributePath) {
+      callback.onSuccess();
+    }
+
+    @Override
+    public void onError(@Nullable ChipAttributePath attributePath, Exception e) {
+      callback.onError(e);
+    }
+  }
+
+  abstract static class InvokeCallbackImpl implements InvokeCallback {
+    private BaseClusterCallback callback;
+
+    private static final long CHIP_ERROR_UNSUPPORTED_COMMAND = 0x81;
+
+    InvokeCallbackImpl(BaseClusterCallback callback) {
+      this.callback = callback;
+    }
+
+    public void onError(Exception e) {
+      callback.onError(e);
+    }
+
+    public void onResponse(InvokeElement invokeElement, long successCode) {
+      byte[] tlv = invokeElement.getTlvByteArray();
+      if (tlv == null) {
+        onResponse(null);
+        return;
+      }
+      BaseTLVType value = BaseChipCluster.decodeFromTlv(tlv);
+      if (value == null || value.type() != TLVType.Struct) {
+        callback.onError(new ChipClusterException(CHIP_ERROR_UNSUPPORTED_COMMAND));
+        return;
+      }
+      onResponse((StructType)value);
+    }
+
+    public abstract void onResponse(StructType value);
+  }
 {% for cluster in clientClusters | sort(attribute='code') %}
 {%- set typeLookup = idl | createLookupContext(cluster) %}
   public static class {{cluster.name}}Cluster extends BaseChipCluster {
     public static final long CLUSTER_ID = {{cluster.code}}L;
+{% for attribute in cluster.attributes | sort(attribute='code') %}
+    private static final long {{attribute.definition.name | constcase}}_ATTRIBUTE_ID = {{attribute.definition.code}}L;
+{%- endfor %}
 
     public {{cluster.name}}Cluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 {% for command in cluster.commands | sort(attribute='code') -%}
 {%- set callbackName = command | javaCommandCallbackName() -%}
 {%- if not command.is_timed_invoke %}
@@ -175,13 +386,13 @@ public class ChipClusters {
 {%- endfor -%}
 {%- endif -%}
     ) {
-      {{command.name | lowfirst_except_acronym}}(chipClusterPtr, callback
+      {{command.name | lowfirst_except_acronym}}(callback
 {%- if command.input_param -%}
 {%- for field in (cluster.structs | named(command.input_param)).fields -%}
     , {{field.name | lowfirst_except_acronym}}
 {%- endfor -%}
 {%- endif -%}
-    , null);
+    , 0);
     }
 {%- endif %}
 
@@ -193,32 +404,67 @@ public class ChipClusters {
 {%- endfor -%}
 {%- endif -%}
     , int timedInvokeTimeoutMs) {
-      {{command.name | lowfirst_except_acronym}}(chipClusterPtr, callback
+      final long commandId = {{command.code}}L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
 {%- if command.input_param -%}
 {%- for field in (cluster.structs | named(command.input_param)).fields -%}
-    , {{field.name | lowfirst_except_acronym}}
-{%- endfor -%}
+{%- set encodable = field | asEncodable(typeLookup) %}
+      final long {{field.name | lowfirst_except_acronym}}FieldID = {{field.code}}L;
+      BaseTLVType {{field.name | lowfirst_except_acronym}}tlvValue = {{encode_tlv(cluster, encodable, (field.name | lowfirst_except_acronym), 0)}};
+      elements.add(new StructElement({{field.name | lowfirst_except_acronym}}FieldID, {{field.name | lowfirst_except_acronym}}tlvValue));
+{% endfor -%}
+{%- endif %}
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+{%- if command | isCommandNotDefaultCallback() %}
+{%- for field in (cluster.structs | named(command.output_param)).fields -%}
+{%- set encodable = field | asEncodable(typeLookup) %}
+{%- set encodable2 = field | asEncodable(typeLookup) %}
+          final long {{field.name | lowfirst_except_acronym}}FieldID = {{field.code}}L;
+          {{encode_value(cluster, encodable, 0)}} {{field.name | lowfirst_except_acronym}}
+{%- if encodable2.is_nullable -%}
+{{" = null"}}
+{%- elif encodable2.is_optional -%}
+{{" = Optional.empty()"}}
+{%- else -%}
+{{" = null"}}
 {%- endif -%}
-    , timedInvokeTimeoutMs);
-    }
-{% endfor %}
-{%- for command in cluster.commands | sort(attribute='code') -%}
-{%- set callbackName = command | javaCommandCallbackName() %}
-    private native void {{command.name | lowfirst_except_acronym}}(long chipClusterPtr, {{callbackName}}Callback callback
-{%- if command.input_param -%}
-{%- for field in (cluster.structs | named(command.input_param)).fields -%}
-{%- set encodable = field | asEncodable(typeLookup) -%}
-    , {{encode_value(cluster, encodable, 0)}} {{field.name | lowfirst_except_acronym}}
+;
+{%- endfor %}
+          for (StructElement element: invokeStructValue.value()) {
+{%- for field in (cluster.structs | named(command.output_param)).fields -%}
+{%- set encodable = field | asEncodable(typeLookup) %}
+            {% if loop.index0 > 0 -%}{{"} else "}}{%- endif -%}if (element.contextTagNum() == {{field.name | lowfirst_except_acronym}}FieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.{{get_tlvType(encodable)}}) {
+                {{get_tlvType(encodable)}}Type castingValue = element.value({{get_tlvType(encodable)}}Type.class);
+                {{field.name | lowfirst_except_acronym}} = {{decode_tlv(cluster, encodable, "castingValue", 0)}};
+              }
 {%- endfor -%}
-{%- endif -%}
-    , @Nullable Integer timedInvokeTimeoutMs);
+{% raw %}
+            }
+{%- endraw %}
+          }
+          callback.onSuccess(
+{%- for field in (cluster.structs | named(command.output_param)).fields -%}
+      {{field.name | lowfirst_except_acronym}}
+      {%- if loop.index0 < loop.length - 1 -%}{{", "}}{%- endif -%}
+{%- endfor -%}
+            );
+{%- else %}
+          callback.onSuccess();
+{%- endif %}
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 {% endfor %}
 {%- set already_handled_command = [] -%}
 {%- for command in cluster.commands | sort(attribute='code') -%}
 {%- if command | isCommandNotDefaultCallback() -%}
 {%- set callbackName = command | javaCommandCallbackName() -%}
 {%- if callbackName not in already_handled_command %}
-    public interface {{callbackName}}Callback {
+    public interface {{callbackName}}Callback extends BaseClusterCallback {
       void onSuccess(
 {%- for field in (cluster.structs | named(command.output_param)).fields -%}
 {%- set encodable = field | asEncodable(typeLookup) -%}
@@ -226,7 +472,6 @@ public class ChipClusters {
       {%- if loop.index0 < loop.length - 1 -%}{{", "}}{%- endif -%}
 {%- endfor -%}
       );
-      void onError(Exception error);
     }
 {% if already_handled_command.append(callbackName) -%}
 {#- This block does nothing, it only exists to append to already_handled_command. -#}
@@ -239,65 +484,71 @@ public class ChipClusters {
 {%- set encodable = attribute.definition | asEncodable(typeLookup) -%}
 {%- set interfaceName = attribute | javaAttributeCallbackName(typeLookup) -%}
 {%- if interfaceName not in already_handled_attribute %}
-    public interface {{interfaceName}} {
+    public interface {{interfaceName}} extends BaseAttributeCallback {
       void onSuccess({{encode_value_without_optional(cluster, encodable, 0)}} value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 {% if already_handled_attribute.append(interfaceName) -%}
 {#- This block does nothing, it only exists to append to already_handled_attribute. -#}
 {%- endif -%}
 {%- endif -%}
 {% endfor -%}
-{% for attribute in cluster.attributes | sort(attribute='code') %}
+{% for attribute in cluster.attributes | sort(attribute='code') -%}
+{%- if attribute | isFabricScopedList(typeLookup) %}
     public void read{{attribute.definition.name | upfirst}}Attribute(
         {{attribute | javaAttributeCallbackName(typeLookup) }} callback) {
-        read{{attribute.definition.name | upfirst}}Attribute(chipClusterPtr, callback
-{%- if attribute | isFabricScopedList(typeLookup) -%}
-, true
-{%- endif -%}
-      );
+      read{{attribute.definition.name | upfirst}}AttributeWithFabricFilter(callback, true);
     }
-{% if attribute | isFabricScopedList(typeLookup) %}
+
     public void read{{attribute.definition.name | upfirst}}AttributeWithFabricFilter(
         {{attribute | javaAttributeCallbackName(typeLookup) }} callback, boolean isFabricFiltered) {
-        read{{attribute.definition.name | upfirst}}Attribute(chipClusterPtr, callback, isFabricFiltered);
-    }
+{%- else %}
+    public void read{{attribute.definition.name | upfirst}}Attribute(
+        {{attribute | javaAttributeCallbackName(typeLookup) }} callback) {
+{%- endif %}
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, {{attribute.definition.name | constcase}}_ATTRIBUTE_ID);
 
-{% endif -%}
-{%- if attribute.is_writable %}
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            {%- set encodable = attribute.definition | asEncodable(typeLookup) %}
+            {{encode_value_without_optional(cluster, encodable, 0)}} value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, {{attribute.definition.name | constcase}}_ATTRIBUTE_ID, {% if attribute | isFabricScopedList(typeLookup) -%}isFabricFiltered{%- else -%}true{%- endif -%});
+    }
+{% if attribute.is_writable %}
 {%- set encodable = attribute.definition | asEncodable(typeLookup) -%}
 {%- set encodable2 = attribute.definition | asEncodable(typeLookup) -%}
+{%- set encodable3 = attribute.definition | asEncodable(typeLookup) -%}
 {%- if not attribute.requires_timed_write %}
     public void write{{attribute.definition.name | upfirst}}Attribute(DefaultClusterCallback callback, {{encode_value_without_optional_nullable(cluster, encodable, 0)}} value) {
-        write{{attribute.definition.name | upfirst}}Attribute(chipClusterPtr, callback, value, null);
+      write{{attribute.definition.name | upfirst}}Attribute(callback, value, 0);
     }
 {% endif %}
     public void write{{attribute.definition.name | upfirst}}Attribute(DefaultClusterCallback callback, {{encode_value_without_optional_nullable(cluster, encodable2, 0)}} value, int timedWriteTimeoutMs) {
-        write{{attribute.definition.name | upfirst}}Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      {%- if encodable3.is_optional %}
+      BaseTLVType tlvValue = {{encode_tlv(cluster, encodable3.without_optional(), "value", 0)}};
+      {%- else %}
+      BaseTLVType tlvValue = {{encode_tlv(cluster, encodable3, "value", 0)}};
+      {%- endif %}
+      writeAttribute(new WriteAttributesCallbackImpl(callback), {{attribute.definition.name | constcase}}_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 {% endif %}
 {%- if attribute.is_subscribable %}
     public void subscribe{{attribute.definition.name | upfirst}}Attribute(
         {{attribute | javaAttributeCallbackName(typeLookup) }} callback, int minInterval, int maxInterval) {
-        subscribe{{attribute.definition.name | upfirst}}Attribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, {{attribute.definition.name | constcase}}_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            {%- set encodable = attribute.definition | asEncodable(typeLookup) %}
+            {{encode_value_without_optional(cluster, encodable, 0)}} value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, {{attribute.definition.name | constcase}}_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 {% endif -%}
-{%- endfor %}
-{%- for attribute in cluster.attributes %}
-    private native void read{{attribute.definition.name | upfirst}}Attribute(long chipClusterPtr, {{attribute | javaAttributeCallbackName(typeLookup) }} callback
-{%- if attribute | isFabricScopedList(typeLookup) -%}
-    , boolean isFabricFiltered
-{%- endif -%}
-    );
-{% if attribute.is_writable -%}
-{%- set encodable = attribute.definition | asEncodable(typeLookup) %}
-    private native void write{{attribute.definition.name | upfirst}}Attribute(long chipClusterPtr, DefaultClusterCallback callback, {{encode_value_without_optional_nullable(cluster, encodable, 0)}} value, @Nullable Integer timedWriteTimeoutMs);
-{% endif -%}
-{% if attribute.is_subscribable %}
-    private native void subscribe{{attribute.definition.name | upfirst}}Attribute(long chipClusterPtr, {{attribute | javaAttributeCallbackName(typeLookup) }} callback, int minInterval, int maxInterval);
-{% endif -%}
-{% endfor -%}
+{%- endfor -%}
 {% raw %}  }
 {% endraw %}
 {%- endfor -%}
diff --git a/scripts/py_matter_idl/matter_idl/generators/java/ChipEventStructs_java.jinja b/scripts/py_matter_idl/matter_idl/generators/java/ChipEventStructs_java.jinja
index aa1a2fed451cd3..95f733f9b986b1 100644
--- a/scripts/py_matter_idl/matter_idl/generators/java/ChipEventStructs_java.jinja
+++ b/scripts/py_matter_idl/matter_idl/generators/java/ChipEventStructs_java.jinja
@@ -12,6 +12,45 @@
     {{encodable.boxed_java_type}}
   {%- endif -%}
 {%- endmacro -%}
+
+{%- macro encode_tlv(source, encodable, variable, depth) -%}
+  {%- if encodable.is_nullable -%}
+    {{variable}} != null ? {{encode_tlv(source, encodable.without_nullable(), variable, depth + 1)}} : new NullType()
+  {%- elif encodable.is_optional -%}
+    {{variable}}.<BaseTLVType>map(({{"nonOptional{}".format(variable)}}) -> {{encode_tlv(source, encodable.without_optional(), "nonOptional{}".format(variable), depth + 1)}}).orElse(new EmptyType())
+  {%- elif encodable.is_list -%}
+    ArrayType.generateArrayType({{variable}}, ({{"element{}".format(variable)}}) -> {{encode_tlv(source, encodable.without_list(), "element{}".format(variable), depth + 1)}})
+  {%- elif encodable.is_struct -%}
+    {%- set struct = encodable.get_underlying_struct() -%}
+    {{variable}}.encodeTlv()
+  {%- else -%}
+    new {{encodable.java_tlv_type}}Type({{variable}})
+  {%- endif -%}
+{%- endmacro -%}
+
+{%- macro decode_tlv(source, encodable, variable, depth) -%}
+  {%- if encodable.is_optional -%}
+    Optional.of({{decode_tlv(source, encodable.without_optional(), variable, depth + 1)}})
+  {%- elif encodable.is_list -%}
+    {{variable}}.map(({{"element{}".format(variable)}}) -> {{decode_tlv(source, encodable.without_list(), "element{}".format(variable), depth + 1)}})
+  {%- elif encodable.is_struct -%}
+    {%- set struct = encodable.get_underlying_struct() -%}
+    ChipStructs.{{source.name}}Cluster{{struct.name}}.decodeTlv({{variable}})
+  {%- else -%}
+    {{variable}}.value({{encodable.boxed_java_type}}.class)
+  {%- endif -%}
+{%- endmacro -%}
+
+{%- macro get_tlvType(encodable) -%}
+  {%- if encodable.is_list -%}
+    Array
+  {%- elif encodable.is_struct -%}
+    Struct
+  {%- else -%}
+    {{encodable.java_tlv_type}}
+  {%- endif -%}
+{%- endmacro -%}
+
 /*
  *
  *    Copyright (c) 2023 Project CHIP Authors
@@ -35,6 +74,8 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Optional;
 
+import static chip.devicecontroller.ChipTLVType.*;
+
 public class ChipEventStructs {
 {%- for cluster in clientClusters | sort(attribute='code') -%}
 {%- set typeLookup = idl | createLookupContext(cluster) %}
@@ -45,6 +86,12 @@ public static class {{cluster.name}}Cluster{{event.name}}Event {
   {%- set encodable = field | asEncodable(typeLookup) %}
   public {{encode_value(cluster, encodable, 0)}} {{field.name}};
   {%- endfor %}
+
+  {%- for field in event.fields %}
+  {%- set encodable = field | asEncodable(typeLookup) %}
+  private static final long {{field.name | constcase}}_ID = {{field.code}}L;
+  {%- endfor %}
+
   public {{cluster.name}}Cluster{{event.name}}Event(
     {%- for field in event.fields %}
     {%- set encodable = field | asEncodable(typeLookup) %}
@@ -58,6 +105,54 @@ public static class {{cluster.name}}Cluster{{event.name}}Event {
     {%- endfor %}
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    {%- for field in event.fields %}
+    {%- set encodable = field | asEncodable(typeLookup) %}
+    values.add(new StructElement({{field.name | constcase}}_ID, {{encode_tlv(cluster, encodable, field.name, 0)}}));
+    {%- endfor %}
+
+    return new StructType(values);
+  }
+
+  public static {{cluster.name}}Cluster{{event.name}}Event decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+
+    {%- for field in event.fields %}
+{%- set encodable = field | asEncodable(typeLookup) %}
+{%- set encodable2 = field | asEncodable(typeLookup) %}
+    {{encode_value(cluster, encodable, 0)}} {{field.name | lowfirst_except_acronym}}
+{%- if encodable2.is_nullable -%}
+{{" = null"}}
+{%- elif encodable2.is_optional -%}
+{{" = Optional.empty()"}}
+{%- else -%}
+{{" = null"}}
+{%- endif -%}
+;
+{%- endfor %}
+    for (StructElement element: ((StructType)tlvValue).value()) {
+{%- for field in event.fields -%}
+{%- set encodable = field | asEncodable(typeLookup) %}
+      {% if loop.index0 > 0 -%}{{"} else "}}{%- endif -%}if (element.contextTagNum() == {{field.name | constcase}}_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.{{get_tlvType(encodable)}}) {
+          {{get_tlvType(encodable)}}Type castingValue = element.value({{get_tlvType(encodable)}}Type.class);
+          {{field.name | lowfirst_except_acronym}} = {{decode_tlv(cluster, encodable, "castingValue", 0)}};
+        }
+{%- endfor -%}
+{% raw %}
+      }
+{%- endraw %}
+    }
+    return new {{cluster.name}}Cluster{{event.name}}Event(
+  {%- for field in event.fields %}
+      {{field.name}}{%- if loop.index0 < loop.length - 1 -%}{{","}}{%- endif %}
+  {%- endfor %}
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
diff --git a/scripts/py_matter_idl/matter_idl/generators/java/ChipStructs_java.jinja b/scripts/py_matter_idl/matter_idl/generators/java/ChipStructs_java.jinja
index 8001e95bfeb656..a19d6cd5766b12 100644
--- a/scripts/py_matter_idl/matter_idl/generators/java/ChipStructs_java.jinja
+++ b/scripts/py_matter_idl/matter_idl/generators/java/ChipStructs_java.jinja
@@ -12,6 +12,45 @@
     {{encodable.boxed_java_type}}
   {%- endif -%}
 {%- endmacro -%}
+
+{%- macro encode_tlv(source, encodable, variable, depth) -%}
+  {%- if encodable.is_nullable -%}
+    {{variable}} != null ? {{encode_tlv(source, encodable.without_nullable(), variable, depth + 1)}} : new NullType()
+  {%- elif encodable.is_optional -%}
+    {{variable}}.<BaseTLVType>map(({{"nonOptional{}".format(variable)}}) -> {{encode_tlv(source, encodable.without_optional(), "nonOptional{}".format(variable), depth + 1)}}).orElse(new EmptyType())
+  {%- elif encodable.is_list -%}
+    ArrayType.generateArrayType({{variable}}, ({{"element{}".format(variable)}}) -> {{encode_tlv(source, encodable.without_list(), "element{}".format(variable), depth + 1)}})
+  {%- elif encodable.is_struct -%}
+    {%- set struct = encodable.get_underlying_struct() -%}
+    {{variable}}.encodeTlv()
+  {%- else -%}
+    new {{encodable.java_tlv_type}}Type({{variable}})
+  {%- endif -%}
+{%- endmacro -%}
+
+{%- macro decode_tlv(source, encodable, variable, depth) -%}
+  {%- if encodable.is_optional -%}
+    Optional.of({{decode_tlv(source, encodable.without_optional(), variable, depth + 1)}})
+  {%- elif encodable.is_list -%}
+    {{variable}}.map(({{"element{}".format(variable)}}) -> {{decode_tlv(source, encodable.without_list(), "element{}".format(variable), depth + 1)}})
+  {%- elif encodable.is_struct -%}
+    {%- set struct = encodable.get_underlying_struct() -%}
+    ChipStructs.{{source.name}}Cluster{{struct.name}}.decodeTlv({{variable}})
+  {%- else -%}
+    {{variable}}.value({{encodable.boxed_java_type}}.class)
+  {%- endif -%}
+{%- endmacro -%}
+
+{%- macro get_tlvType(encodable) -%}
+  {%- if encodable.is_list -%}
+    Array
+  {%- elif encodable.is_struct -%}
+    Struct
+  {%- else -%}
+    {{encodable.java_tlv_type}}
+  {%- endif -%}
+{%- endmacro -%}
+
 /*
  *
  *    Copyright (c) 2023 Project CHIP Authors
@@ -35,6 +74,8 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Optional;
 
+import static chip.devicecontroller.ChipTLVType.*;
+
 public class ChipStructs {
 {%- for cluster in clientClusters | sort(attribute='code') -%}
 {%- set typeLookup = idl | createLookupContext(cluster) %}
@@ -45,6 +86,12 @@ public static class {{cluster.name}}Cluster{{struct.name}} {
   {%- set encodable = field | asEncodable(typeLookup) %}
   public {{encode_value(cluster, encodable, 0)}} {{field.name}};
   {%- endfor %}
+
+  {%- for field in struct.fields %}
+  {%- set encodable = field | asEncodable(typeLookup) %}
+  private static final long {{field.name | constcase}}_ID = {{field.code}}L;
+  {%- endfor %}
+
   public {{cluster.name}}Cluster{{struct.name}}(
     {%- for field in struct.fields %}
     {%- set encodable = field | asEncodable(typeLookup) %}
@@ -58,6 +105,54 @@ public static class {{cluster.name}}Cluster{{struct.name}} {
     {%- endfor %}
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    {%- for field in struct.fields %}
+    {%- set encodable = field | asEncodable(typeLookup) %}
+    values.add(new StructElement({{field.name | constcase}}_ID, {{encode_tlv(cluster, encodable, field.name, 0)}}));
+    {%- endfor %}
+
+    return new StructType(values);
+  }
+
+  public static {{cluster.name}}Cluster{{struct.name}} decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+
+    {%- for field in struct.fields %}
+{%- set encodable = field | asEncodable(typeLookup) %}
+{%- set encodable2 = field | asEncodable(typeLookup) %}
+    {{encode_value(cluster, encodable, 0)}} {{field.name | lowfirst_except_acronym}}
+{%- if encodable2.is_nullable -%}
+{{" = null"}}
+{%- elif encodable2.is_optional -%}
+{{" = Optional.empty()"}}
+{%- else -%}
+{{" = null"}}
+{%- endif -%}
+;
+{%- endfor %}
+    for (StructElement element: ((StructType)tlvValue).value()) {
+{%- for field in struct.fields -%}
+{%- set encodable = field | asEncodable(typeLookup) %}
+      {% if loop.index0 > 0 -%}{{"} else "}}{%- endif -%}if (element.contextTagNum() == {{field.name | constcase}}_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.{{get_tlvType(encodable)}}) {
+          {{get_tlvType(encodable)}}Type castingValue = element.value({{get_tlvType(encodable)}}Type.class);
+          {{field.name | lowfirst_except_acronym}} = {{decode_tlv(cluster, encodable, "castingValue", 0)}};
+        }
+{%- endfor -%}
+{% raw %}
+      }
+{%- endraw %}
+    }
+    return new {{cluster.name}}Cluster{{struct.name}}(
+  {%- for field in struct.fields %}
+      {{field.name}}{%- if loop.index0 < loop.length - 1 -%}{{","}}{%- endif %}
+  {%- endfor %}
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
diff --git a/scripts/py_matter_idl/matter_idl/generators/java/__init__.py b/scripts/py_matter_idl/matter_idl/generators/java/__init__.py
index 3ab3ed1a586781..7b1c80bb13bb1c 100644
--- a/scripts/py_matter_idl/matter_idl/generators/java/__init__.py
+++ b/scripts/py_matter_idl/matter_idl/generators/java/__init__.py
@@ -509,6 +509,37 @@ def boxed_java_type(self):
         else:
             return "Object"
 
+    @property
+    def java_tlv_type(self):
+        t = ParseDataType(self.data_type, self.context)
+
+        if isinstance(t, FundamentalType):
+            if t == FundamentalType.BOOL:
+                return "Boolean"
+            elif t == FundamentalType.FLOAT:
+                return "Float"
+            elif t == FundamentalType.DOUBLE:
+                return "Double"
+            else:
+                raise Exception("Unknown fundamental type")
+        elif isinstance(t, BasicInteger):
+            # the >= 3 will include int24_t to be considered "long"
+            if t.is_signed:
+                return "Int"
+            else:
+                return "UInt"
+        elif isinstance(t, BasicString):
+            if t.is_binary:
+                return "ByteArray"
+            else:
+                return "String"
+        elif isinstance(t, IdlEnumType):
+            return "UInt"
+        elif isinstance(t, IdlBitmapType):
+            return "UInt"
+        else:
+            return "Any"
+
     @property
     def kotlin_type(self):
         t = ParseDataType(self.data_type, self.context)
diff --git a/scripts/py_matter_idl/matter_idl/tests/outputs/several_clusters/java/ChipClusters.java b/scripts/py_matter_idl/matter_idl/tests/outputs/several_clusters/java/ChipClusters.java
index 1523980cb4d985..62d0167f1d567c 100644
--- a/scripts/py_matter_idl/matter_idl/tests/outputs/several_clusters/java/ChipClusters.java
+++ b/scripts/py_matter_idl/matter_idl/tests/outputs/several_clusters/java/ChipClusters.java
@@ -17,68 +17,84 @@
 
 package chip.devicecontroller;
 
+import chip.devicecontroller.model.AttributeState;
+import chip.devicecontroller.model.AttributeWriteRequest;
+import chip.devicecontroller.model.ChipAttributePath;
+import chip.devicecontroller.model.ChipEventPath;
+import chip.devicecontroller.model.ClusterState;
+import chip.devicecontroller.model.EndpointState;
+import chip.devicecontroller.model.InvokeElement;
+import chip.devicecontroller.model.NodeState;
+
 import javax.annotation.Nullable;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Optional;
 
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import static chip.devicecontroller.ChipTLVType.*;
+
 public class ChipClusters {
 
-  public interface DefaultClusterCallback {
+  public interface BaseClusterCallback {
+    void onError(Exception error);
+  }
+
+  public interface DefaultClusterCallback extends BaseClusterCallback {
     void onSuccess();
+  }
+
+  public interface BaseAttributeCallback {
     void onError(Exception error);
+    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
-  public interface CharStringAttributeCallback {
+  public interface CharStringAttributeCallback extends BaseAttributeCallback {
     /** Indicates a successful read for a CHAR_STRING attribute. */
     void onSuccess(String value);
-    void onError(Exception error);
-    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
-  public interface OctetStringAttributeCallback {
+  public interface OctetStringAttributeCallback extends BaseAttributeCallback {
     /** Indicates a successful read for an OCTET_STRING attribute. */
     void onSuccess(byte[] value);
-    void onError(Exception error);
-    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
-  public interface IntegerAttributeCallback {
+  public interface IntegerAttributeCallback extends BaseAttributeCallback {
     void onSuccess(int value);
-    void onError(Exception error);
-    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
-  public interface LongAttributeCallback {
+  public interface LongAttributeCallback extends BaseAttributeCallback {
     void onSuccess(long value);
-    void onError(Exception error);
-    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
-  public interface BooleanAttributeCallback {
+  public interface BooleanAttributeCallback extends BaseAttributeCallback {
     void onSuccess(boolean value);
-    void onError(Exception error);
-    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
-  public interface FloatAttributeCallback {
+  public interface FloatAttributeCallback extends BaseAttributeCallback {
     void onSuccess(float value);
-    void onError(Exception error);
-    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
-  public interface DoubleAttributeCallback {
+  public interface DoubleAttributeCallback extends BaseAttributeCallback {
     void onSuccess(double value);
-    void onError(Exception error);
-    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
   public static abstract class BaseChipCluster {
     protected long chipClusterPtr;
 
-    public BaseChipCluster(long devicePtr, int endpointId) {
-      chipClusterPtr = initWithDevice(devicePtr, endpointId);
+    protected long devicePtr;
+    protected int endpointId;
+    protected long clusterId;
+
+    private Optional<Long> timeoutMillis = Optional.empty();
+
+    public BaseChipCluster(long devicePtr, int endpointId, long clusterId) {
+      this.devicePtr = devicePtr;
+      this.endpointId = endpointId;
+      this.clusterId = clusterId;
     }
 
     /**
@@ -87,22 +103,64 @@ public BaseChipCluster(long devicePtr, int endpointId) {
      * empty optional, the default timeout will be used.
      */
     public void setCommandTimeout(Optional<Long> timeoutMillis) {
-      setCommandTimeout(chipClusterPtr, timeoutMillis);
+      this.timeoutMillis = timeoutMillis;
     }
 
-    private native void setCommandTimeout(long clusterPtr, Optional<Long> timeoutMillis);
-
     /** Returns the current timeout (in milliseconds) for commands sent through this cluster. */
     public Optional<Long> getCommandTimeout() {
-      Optional<Long> timeout = getCommandTimeout(chipClusterPtr);
-      return timeout == null ? Optional.empty() : timeout;
+      return timeoutMillis == null ? Optional.empty() : timeoutMillis;
     }
 
-    private native Optional<Long> getCommandTimeout(long clusterPtr);
-
+    @Deprecated
     public abstract long initWithDevice(long devicePtr, int endpointId);
 
-    public native void deleteCluster(long chipClusterPtr);
+    protected void readAttribute(
+        ReportCallbackImpl callback,
+        long attributeId,
+        boolean isFabricFiltered) {
+      ReportCallbackJni jniCallback = new ReportCallbackJni(null, callback, null);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, attributeId);
+      ChipDeviceController.read(0, jniCallback.getCallbackHandle(), devicePtr, Arrays.asList(path), null, isFabricFiltered, timeoutMillis.orElse(0L).intValue(), null);
+    }
+
+    protected void writeAttribute(
+        WriteAttributesCallbackImpl callback,
+        long attributeId,
+        BaseTLVType value,
+        int timedRequestTimeoutMs) {
+      WriteAttributesCallbackJni jniCallback = new WriteAttributesCallbackJni(callback);
+      byte[] tlv = encodeToTlv(value);
+      AttributeWriteRequest writeRequest = AttributeWriteRequest.newInstance(endpointId, clusterId, attributeId, tlv);
+      ChipDeviceController.write(0, jniCallback.getCallbackHandle(), devicePtr, Arrays.asList(writeRequest), timedRequestTimeoutMs, timeoutMillis.orElse(0L).intValue());
+    }
+
+    protected void subscribeAttribute(
+        ReportCallbackImpl callback,
+        long attributeId,
+        int minInterval,
+        int maxInterval) {
+      ReportCallbackJni jniCallback = new ReportCallbackJni(callback, callback, null);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, attributeId);
+      ChipDeviceController.subscribe(0, jniCallback.getCallbackHandle(), devicePtr, Arrays.asList(path), null, minInterval, maxInterval, false, true, timeoutMillis.orElse(0L).intValue(), null);
+    }
+
+    protected void invoke(
+        InvokeCallbackImpl callback,
+        long commandId,
+        BaseTLVType value,
+        int timedRequestTimeoutMs) {
+      InvokeCallbackJni jniCallback = new InvokeCallbackJni(callback);
+      byte[] tlv = encodeToTlv(value);
+      InvokeElement element = InvokeElement.newInstance(endpointId, clusterId, commandId, tlv, null);
+      ChipDeviceController.invoke(0, jniCallback.getCallbackHandle(), devicePtr, element, timedRequestTimeoutMs, timeoutMillis.orElse(0L).intValue());
+    }
+
+    private static native byte[] encodeToTlv(BaseTLVType value);
+
+    static native BaseTLVType decodeFromTlv(byte[] tlv);
+
+    @Deprecated
+    public void deleteCluster(long chipClusterPtr) {}
     
     @SuppressWarnings("deprecation")
     protected void finalize() throws Throwable {
@@ -115,148 +173,323 @@ protected void finalize() throws Throwable {
     }
   }
 
+  abstract static class ReportCallbackImpl implements ReportCallback, SubscriptionEstablishedCallback {
+    private BaseAttributeCallback callback;
+    private ChipAttributePath path;
+
+    private static final long CHIP_ERROR_UNSUPPORTED_ATTRIBUTE = 0x86;
+
+    ReportCallbackImpl(BaseAttributeCallback callback, ChipAttributePath path) {
+      this.callback = callback;
+      this.path = path;
+    }
+
+    @Override
+    public void onError(
+        @Nullable ChipAttributePath attributePath,
+        @Nullable ChipEventPath eventPath,
+        @Nonnull Exception e) {
+      callback.onError(e);
+    }
+
+    @Override
+    public void onReport(NodeState nodeState) {
+      if (nodeState == null) {
+        callback.onError(new ChipClusterException());
+        return;
+      }
+
+      EndpointState endpointState = nodeState.getEndpointState((int)path.getEndpointId().getId());
+      if (endpointState == null) {
+        callback.onError(new ChipClusterException(CHIP_ERROR_UNSUPPORTED_ATTRIBUTE));
+        return;
+      }
+
+      ClusterState clusterState = endpointState.getClusterState(path.getClusterId().getId());
+      if (clusterState == null) {
+        callback.onError(new ChipClusterException(CHIP_ERROR_UNSUPPORTED_ATTRIBUTE));
+        return;
+      }
+
+      AttributeState attributeState = clusterState.getAttributeState(path.getAttributeId().getId());
+      if (attributeState == null) {
+        callback.onError(new ChipClusterException(CHIP_ERROR_UNSUPPORTED_ATTRIBUTE));
+        return;
+      }
+
+      byte[] tlv = attributeState.getTlv();
+      if (tlv == null) {
+          callback.onError(new ChipClusterException(CHIP_ERROR_UNSUPPORTED_ATTRIBUTE));
+          return;
+      }
+
+      onSuccess(tlv);
+    }
+
+    @Override
+    public void onSubscriptionEstablished(long subscriptionId) {
+      callback.onSubscriptionEstablished(subscriptionId);
+    }
+
+    public abstract void onSuccess(byte[] tlv);
+  }
+
+  static class WriteAttributesCallbackImpl implements WriteAttributesCallback {
+    private DefaultClusterCallback callback;
+
+    WriteAttributesCallbackImpl(DefaultClusterCallback callback) {
+      this.callback = callback;
+    }
+
+    @Override
+    public void onResponse(ChipAttributePath attributePath) {
+      callback.onSuccess();
+    }
+
+    @Override
+    public void onError(@Nullable ChipAttributePath attributePath, Exception e) {
+      callback.onError(e);
+    }
+  }
+
+  abstract static class InvokeCallbackImpl implements InvokeCallback {
+    private BaseClusterCallback callback;
+
+    private static final long CHIP_ERROR_UNSUPPORTED_COMMAND = 0x81;
+
+    InvokeCallbackImpl(BaseClusterCallback callback) {
+      this.callback = callback;
+    }
+
+    public void onError(Exception e) {
+      callback.onError(e);
+    }
+
+    public void onResponse(InvokeElement invokeElement, long successCode) {
+      byte[] tlv = invokeElement.getTlvByteArray();
+      if (tlv == null) {
+        onResponse(null);
+        return;
+      }
+      BaseTLVType value = BaseChipCluster.decodeFromTlv(tlv);
+      if (value == null || value.type() != TLVType.Struct) {
+        callback.onError(new ChipClusterException(CHIP_ERROR_UNSUPPORTED_COMMAND));
+        return;
+      }
+      onResponse((StructType)value);
+    }
+
+    public abstract void onResponse(StructType value);
+  }
+
   public static class FirstCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1L;
 
+    private static final long SOME_INTEGER_ATTRIBUTE_ID = 1L;
+
     public FirstCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void readSomeIntegerAttribute(
         IntegerAttributeCallback callback) {
-        readSomeIntegerAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SOME_INTEGER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SOME_INTEGER_ATTRIBUTE_ID, true);
     }
 
     public void writeSomeIntegerAttribute(DefaultClusterCallback callback, Integer value) {
-        writeSomeIntegerAttribute(chipClusterPtr, callback, value, null);
+      writeSomeIntegerAttribute(callback, value, 0);
     }
 
     public void writeSomeIntegerAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeSomeIntegerAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), SOME_INTEGER_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeSomeIntegerAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSomeIntegerAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SOME_INTEGER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SOME_INTEGER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
-
-    private native void readSomeIntegerAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeSomeIntegerAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeSomeIntegerAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
   }
 
   public static class SecondCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 2L;
 
+    private static final long FABRICS_ATTRIBUTE_ID = 0L;
+    private static final long SOME_BYTES_ATTRIBUTE_ID = 123L;
+
     public SecondCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface FabricsAttributeCallback {
+    public interface FabricsAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.SecondClusterFabricDescriptorStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readFabricsAttribute(
         FabricsAttributeCallback callback) {
-        readFabricsAttribute(chipClusterPtr, callback, true);
+      readFabricsAttributeWithFabricFilter(callback, true);
     }
 
     public void readFabricsAttributeWithFabricFilter(
         FabricsAttributeCallback callback, boolean isFabricFiltered) {
-        readFabricsAttribute(chipClusterPtr, callback, isFabricFiltered);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FABRICS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.SecondClusterFabricDescriptorStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FABRICS_ATTRIBUTE_ID, isFabricFiltered);
     }
 
-
     public void subscribeFabricsAttribute(
         FabricsAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFabricsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FABRICS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.SecondClusterFabricDescriptorStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FABRICS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSomeBytesAttribute(
         OctetStringAttributeCallback callback) {
-        readSomeBytesAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SOME_BYTES_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            byte[] value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SOME_BYTES_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSomeBytesAttribute(
         OctetStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSomeBytesAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SOME_BYTES_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            byte[] value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SOME_BYTES_ATTRIBUTE_ID, minInterval, maxInterval);
     }
-
-    private native void readFabricsAttribute(long chipClusterPtr, FabricsAttributeCallback callback, boolean isFabricFiltered);
-
-    private native void subscribeFabricsAttribute(long chipClusterPtr, FabricsAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSomeBytesAttribute(long chipClusterPtr, OctetStringAttributeCallback callback);
-
-    private native void subscribeSomeBytesAttribute(long chipClusterPtr, OctetStringAttributeCallback callback, int minInterval, int maxInterval);
   }
 
   public static class ThirdCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 3L;
 
+    private static final long SOME_ENUM_ATTRIBUTE_ID = 10L;
+    private static final long OPTIONS_ATTRIBUTE_ID = 20L;
+
     public ThirdCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void readSomeEnumAttribute(
         IntegerAttributeCallback callback) {
-        readSomeEnumAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SOME_ENUM_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SOME_ENUM_ATTRIBUTE_ID, true);
     }
 
     public void writeSomeEnumAttribute(DefaultClusterCallback callback, Integer value) {
-        writeSomeEnumAttribute(chipClusterPtr, callback, value, null);
+      writeSomeEnumAttribute(callback, value, 0);
     }
 
     public void writeSomeEnumAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeSomeEnumAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), SOME_ENUM_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeSomeEnumAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSomeEnumAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SOME_ENUM_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SOME_ENUM_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOptionsAttribute(
         IntegerAttributeCallback callback) {
-        readOptionsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPTIONS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OPTIONS_ATTRIBUTE_ID, true);
     }
 
     public void writeOptionsAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOptionsAttribute(chipClusterPtr, callback, value, null);
+      writeOptionsAttribute(callback, value, 0);
     }
 
     public void writeOptionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOptionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), OPTIONS_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOptionsAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOptionsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPTIONS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OPTIONS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
-
-    private native void readSomeEnumAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeSomeEnumAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeSomeEnumAttribute(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);
   }
 }
diff --git a/scripts/py_matter_idl/matter_idl/tests/outputs/several_clusters/java/ChipEventStructs.java b/scripts/py_matter_idl/matter_idl/tests/outputs/several_clusters/java/ChipEventStructs.java
index 9124dfd27b2606..11814259543efe 100644
--- a/scripts/py_matter_idl/matter_idl/tests/outputs/several_clusters/java/ChipEventStructs.java
+++ b/scripts/py_matter_idl/matter_idl/tests/outputs/several_clusters/java/ChipEventStructs.java
@@ -21,5 +21,7 @@
 import java.util.Arrays;
 import java.util.Optional;
 
+import static chip.devicecontroller.ChipTLVType.*;
+
 public class ChipEventStructs {
 }
diff --git a/scripts/py_matter_idl/matter_idl/tests/outputs/several_clusters/java/ChipStructs.java b/scripts/py_matter_idl/matter_idl/tests/outputs/several_clusters/java/ChipStructs.java
index 1ff18716d4c8ba..d3cf1f0c7dae79 100644
--- a/scripts/py_matter_idl/matter_idl/tests/outputs/several_clusters/java/ChipStructs.java
+++ b/scripts/py_matter_idl/matter_idl/tests/outputs/several_clusters/java/ChipStructs.java
@@ -21,6 +21,8 @@
 import java.util.Arrays;
 import java.util.Optional;
 
+import static chip.devicecontroller.ChipTLVType.*;
+
 public class ChipStructs {
 public static class SecondClusterFabricDescriptorStruct {
   public byte[] rootPublicKey;
@@ -29,6 +31,13 @@ public static class SecondClusterFabricDescriptorStruct {
   public Long nodeID;
   public String label;
   public Integer fabricIndex;
+  private static final long ROOT_PUBLIC_KEY_ID = 1L;
+  private static final long VENDOR_I_D_ID = 2L;
+  private static final long FABRIC_I_D_ID = 3L;
+  private static final long NODE_I_D_ID = 4L;
+  private static final long LABEL_ID = 5L;
+  private static final long FABRIC_INDEX_ID = 254L;
+
   public SecondClusterFabricDescriptorStruct(
     byte[] rootPublicKey,
     Integer vendorID,
@@ -45,6 +54,71 @@ public SecondClusterFabricDescriptorStruct(
     this.fabricIndex = fabricIndex;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ROOT_PUBLIC_KEY_ID, new ByteArrayType(rootPublicKey)));
+    values.add(new StructElement(VENDOR_I_D_ID, new UIntType(vendorID)));
+    values.add(new StructElement(FABRIC_I_D_ID, new UIntType(fabricID)));
+    values.add(new StructElement(NODE_I_D_ID, new UIntType(nodeID)));
+    values.add(new StructElement(LABEL_ID, new StringType(label)));
+    values.add(new StructElement(FABRIC_INDEX_ID, new UIntType(fabricIndex)));
+
+    return new StructType(values);
+  }
+
+  public static SecondClusterFabricDescriptorStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    byte[] rootPublicKey = null;
+    Integer vendorID = null;
+    Long fabricID = null;
+    Long nodeID = null;
+    String label = null;
+    Integer fabricIndex = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ROOT_PUBLIC_KEY_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+          ByteArrayType castingValue = element.value(ByteArrayType.class);
+          rootPublicKey = castingValue.value(byte[].class);
+        }
+      } else if (element.contextTagNum() == VENDOR_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          vendorID = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == FABRIC_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricID = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == NODE_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          nodeID = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == LABEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          label = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == FABRIC_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricIndex = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new SecondClusterFabricDescriptorStruct(
+      rootPublicKey,
+      vendorID,
+      fabricID,
+      nodeID,
+      label,
+      fabricIndex
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
diff --git a/src/controller/java/BUILD.gn b/src/controller/java/BUILD.gn
index 01617c1f9e50b8..7fb098d4a1a88f 100644
--- a/src/controller/java/BUILD.gn
+++ b/src/controller/java/BUILD.gn
@@ -80,22 +80,6 @@ shared_library("jni") {
     ]
   }
 
-  if (matter_enable_java_generated_api) {
-    sources += [
-      "CHIPDefaultCallbacks.cpp",
-      "CHIPDefaultCallbacks.h",
-      "zap-generated/CHIPClustersWrite-JNI.cpp",
-      "zap-generated/CHIPInvokeCallbacks.cpp",
-      "zap-generated/CHIPInvokeCallbacks.h",
-      "zap-generated/CHIPReadCallbacks.cpp",
-    ]
-
-    deps += [
-      "${chip_root}/src/controller/data_model",
-      "${chip_root}/src/controller/data_model:java-jni-sources",
-    ]
-  }
-
   if (chip_build_controller_dynamic_server) {
     sources += [
       "BdxOTASender.cpp",
@@ -505,6 +489,7 @@ android_library("java") {
       "src/chip/clusterinfo/CommandResponseInfo.java",
       "src/chip/clusterinfo/DelegatedClusterCallback.java",
       "src/chip/clusterinfo/InteractionInfo.java",
+      "src/chip/devicecontroller/ChipTLVType.java",
     ]
   }
 
diff --git a/src/controller/java/BaseCHIPCluster-JNI.cpp b/src/controller/java/BaseCHIPCluster-JNI.cpp
index 830e757c46faf6..780ad8ff736655 100644
--- a/src/controller/java/BaseCHIPCluster-JNI.cpp
+++ b/src/controller/java/BaseCHIPCluster-JNI.cpp
@@ -1,59 +1,383 @@
-#include <controller/CHIPCluster.h>
 #include <jni.h>
+#include <lib/core/CHIPError.h>
+#include <lib/core/TLV.h>
 #include <lib/support/JniReferences.h>
-#include <platform/PlatformManager.h>
+#include <lib/support/JniTypeWrappers.h>
 
 #define JNI_METHOD(RETURN, CLASS_NAME, METHOD_NAME)                                                                                \
     extern "C" JNIEXPORT RETURN JNICALL Java_chip_devicecontroller_ChipClusters_00024##CLASS_NAME##_##METHOD_NAME
 
-JNI_METHOD(void, BaseChipCluster, deleteCluster)(JNIEnv * env, jobject self, jlong clusterPtr)
+#define CHIP_TLV_WRITER_BUFFER_SIZE 1024
+
+jobject decodeValueFromTLV(JNIEnv * env, chip::TLV::TLVReader * data);
+static CHIP_ERROR encodeTLVFromValue(JNIEnv * env, jobject jObject, chip::TLV::TLVWriter & writer, chip::TLV::Tag tag);
+
+jobject decodeValueFromTLV(JNIEnv * env, chip::TLV::TLVReader * data)
 {
-    chip::DeviceLayer::StackLock lock;
-    chip::Controller::ClusterBase * cluster = reinterpret_cast<chip::Controller::ClusterBase *>(clusterPtr);
-    if (cluster != nullptr)
+    chip::TLV::TLVType dataTLVType = data->GetType();
+    switch (dataTLVType)
     {
-        delete cluster;
+    case chip::TLV::kTLVType_SignedInteger: {
+        int64_t val;
+        CHIP_ERROR err = data->Get(val);
+        VerifyOrReturnValue(
+            err == CHIP_NO_ERROR, nullptr,
+            ChipLogError(Controller, "Error: TLV signed integer decoding failed : %" CHIP_ERROR_FORMAT, err.Format()));
+        jclass intTypeCls     = env->FindClass("chip/devicecontroller/ChipTLVType$IntType");
+        jmethodID constructor = env->GetMethodID(intTypeCls, "<init>", "(J)V");
+        return env->NewObject(intTypeCls, constructor, static_cast<jlong>(val));
+    }
+    case chip::TLV::kTLVType_UnsignedInteger: {
+        uint64_t val;
+        CHIP_ERROR err = data->Get(val);
+        VerifyOrReturnValue(
+            err == CHIP_NO_ERROR, nullptr,
+            ChipLogError(Controller, "Error: TLV unsigned integer decoding failed : %" CHIP_ERROR_FORMAT, err.Format()));
+        jclass uintTypeCls    = env->FindClass("chip/devicecontroller/ChipTLVType$UIntType");
+        jmethodID constructor = env->GetMethodID(uintTypeCls, "<init>", "(J)V");
+        return env->NewObject(uintTypeCls, constructor, static_cast<jlong>(val));
+    }
+    case chip::TLV::kTLVType_Boolean: {
+        bool val;
+        CHIP_ERROR err = data->Get(val);
+        VerifyOrReturnValue(err == CHIP_NO_ERROR, nullptr,
+                            ChipLogError(Controller, "Error: TLV boolean decoding failed : %" CHIP_ERROR_FORMAT, err.Format()));
+        jclass booleanTypeCls = env->FindClass("chip/devicecontroller/ChipTLVType$BooleanType");
+        jmethodID constructor = env->GetMethodID(booleanTypeCls, "<init>", "(Z)V");
+        return env->NewObject(booleanTypeCls, constructor, static_cast<jboolean>(val));
+    }
+    case chip::TLV::kTLVType_FloatingPointNumber: {
+        // Try float first
+        float floatValue;
+        CHIP_ERROR err = data->Get(floatValue);
+        if (err == CHIP_NO_ERROR)
+        {
+            jclass floatTypeCls   = env->FindClass("chip/devicecontroller/ChipTLVType$FloatType");
+            jmethodID constructor = env->GetMethodID(floatTypeCls, "<init>", "(F)V");
+            return env->NewObject(floatTypeCls, constructor, static_cast<jfloat>(floatValue));
+        }
+        double val;
+        err = data->Get(val);
+        VerifyOrReturnValue(
+            err == CHIP_NO_ERROR, nullptr,
+            ChipLogError(Controller, "Error: TLV floating point decoding failed : %" CHIP_ERROR_FORMAT, err.Format()));
+        jclass doubleTypeCls        = env->FindClass("chip/devicecontroller/ChipTLVType$DoubleType");
+        jmethodID doubleConstructor = env->GetMethodID(doubleTypeCls, "<init>", "(D)V");
+        return env->NewObject(doubleTypeCls, doubleConstructor, static_cast<jdouble>(val));
+    }
+    case chip::TLV::kTLVType_UTF8String: {
+        chip::CharSpan stringValue;
+        CHIP_ERROR err = data->Get(stringValue);
+        VerifyOrReturnValue(err == CHIP_NO_ERROR, nullptr,
+                            ChipLogError(Controller, "Error: TLV UTF8String decoding failed : %" CHIP_ERROR_FORMAT, err.Format()));
+        chip::UtfString stringObj(env, stringValue);
+        jclass stringTypeCls  = env->FindClass("chip/devicecontroller/ChipTLVType$StringType");
+        jmethodID constructor = env->GetMethodID(stringTypeCls, "<init>", "(Ljava/lang/String;)V");
+        return env->NewObject(stringTypeCls, constructor, stringObj.jniValue());
+    }
+    case chip::TLV::kTLVType_ByteString: {
+        chip::ByteSpan bytesValue;
+        CHIP_ERROR err = data->Get(bytesValue);
+        VerifyOrReturnValue(err == CHIP_NO_ERROR, nullptr,
+                            ChipLogError(Controller, "Error: TLV ByteString decoding failed : %" CHIP_ERROR_FORMAT, err.Format()));
+        chip::ByteArray byteArrayObj(env, bytesValue);
+        jclass stringTypeCls  = env->FindClass("chip/devicecontroller/ChipTLVType$ByteArrayType");
+        jmethodID constructor = env->GetMethodID(stringTypeCls, "<init>", "([B)V");
+        return env->NewObject(stringTypeCls, constructor, byteArrayObj.jniValue());
+    }
+    case chip::TLV::kTLVType_Null: {
+        jclass nullTypeCls    = env->FindClass("chip/devicecontroller/ChipTLVType$NullType");
+        jmethodID constructor = env->GetMethodID(nullTypeCls, "<init>", "()V");
+        return env->NewObject(nullTypeCls, constructor);
+    }
+    case chip::TLV::kTLVType_Structure:
+    case chip::TLV::kTLVType_Array: {
+        chip::TLV::TLVType tlvType;
+        CHIP_ERROR err = data->EnterContainer(tlvType);
+        VerifyOrReturnValue(err == CHIP_NO_ERROR, nullptr,
+                            ChipLogError(Controller, "Error: TLV container entering failed : %" CHIP_ERROR_FORMAT, err.Format()));
+
+        jobject arrayLists;
+        err = chip::JniReferences::GetInstance().CreateArrayList(arrayLists);
+        VerifyOrReturnValue(err == CHIP_NO_ERROR, nullptr,
+                            ChipLogError(Controller, "Error: Create ArrayList object failed : %" CHIP_ERROR_FORMAT, err.Format()));
+
+        while ((err = data->Next()) == CHIP_NO_ERROR)
+        {
+            chip::TLV::Tag tag = data->GetTag();
+            jobject value      = decodeValueFromTLV(env, data);
+            VerifyOrReturnValue(
+                value != nullptr, nullptr,
+                ChipLogError(Controller, "Error when decoding TLV container of type : %" CHIP_ERROR_FORMAT, err.Format()));
+
+            jobject jValue = nullptr;
+            if (dataTLVType == chip::TLV::kTLVType_Structure)
+            {
+                uint64_t tagNum = TagNumFromTag(tag);
+
+                jclass structElementCls = env->FindClass("chip/devicecontroller/ChipTLVType$StructElement");
+                jmethodID constructor =
+                    env->GetMethodID(structElementCls, "<init>", "(JLchip/devicecontroller/ChipTLVType$BaseTLVType;)V");
+
+                jValue = env->NewObject(structElementCls, constructor, static_cast<jlong>(tagNum), value);
+            }
+            else
+            {
+                jValue = value;
+            }
+            err = chip::JniReferences::GetInstance().AddToList(arrayLists, jValue);
+            VerifyOrReturnValue(err == CHIP_NO_ERROR, nullptr,
+                                ChipLogError(Controller, "Error: Add ArrayList object failed : %" CHIP_ERROR_FORMAT, err.Format()));
+        }
+        if (err != CHIP_END_OF_TLV)
+        {
+            ChipLogError(Controller, "Error: TLV container decoding failed: %" CHIP_ERROR_FORMAT, err.Format());
+            return nullptr;
+        }
+
+        err = data->ExitContainer(tlvType);
+        VerifyOrReturnValue(err == CHIP_NO_ERROR, nullptr,
+                            ChipLogError(Controller, "Error: TLV container exiting failed: %" CHIP_ERROR_FORMAT, err.Format()));
+
+        jclass typeCls = nullptr;
+        if (dataTLVType == chip::TLV::kTLVType_Structure)
+        {
+            typeCls = env->FindClass("chip/devicecontroller/ChipTLVType$StructType");
+        }
+        else
+        {
+            typeCls = env->FindClass("chip/devicecontroller/ChipTLVType$ArrayType");
+        }
+        jmethodID constructor = env->GetMethodID(typeCls, "<init>", "(Ljava/util/ArrayList;)V");
+        return env->NewObject(typeCls, constructor, arrayLists);
+    }
+    default:
+        ChipLogError(Controller, "Error: Unsupported TLV type for conversion : %u", data->GetType());
+        return nullptr;
     }
 }
 
-JNI_METHOD(jobject, BaseChipCluster, getCommandTimeout)
-(JNIEnv * env, jobject self, jlong clusterPtr)
+static bool isEqualTLVType(JNIEnv * env, const char * typeName, jobject tlvType)
 {
-    chip::DeviceLayer::StackLock lock;
-    chip::Controller::ClusterBase * cluster = reinterpret_cast<chip::Controller::ClusterBase *>(clusterPtr);
+    jclass tlvEnum = env->FindClass("chip/devicecontroller/ChipTLVType$TLVType");
 
-    chip::Optional<chip::System::Clock::Timeout> timeout = cluster->GetCommandTimeout();
-    if (!timeout.HasValue())
-    {
-        jobject emptyOptional = nullptr;
-        chip::JniReferences::GetInstance().CreateOptional(nullptr, emptyOptional);
-        return emptyOptional;
-    }
+    jfieldID enumFieldID = env->GetStaticFieldID(tlvEnum, typeName, "Lchip/devicecontroller/ChipTLVType$TLVType;");
+    jobject enumObj      = env->GetStaticObjectField(tlvEnum, enumFieldID);
+
+    jmethodID equalsMethodID = env->GetMethodID(tlvEnum, "equals", "(Ljava/lang/Object;)Z");
 
-    jobject timeoutOptional = nullptr;
-    jobject timeoutBoxed    = nullptr;
-    jlong timeoutPrimitive  = static_cast<jlong>(timeout.Value().count());
-    chip::JniReferences::GetInstance().CreateBoxedObject("java/lang/Long", "(J)V", timeoutPrimitive, timeoutBoxed);
-    chip::JniReferences::GetInstance().CreateOptional(timeoutBoxed, timeoutOptional);
-    return timeoutOptional;
+    return (env->CallBooleanMethod(enumObj, equalsMethodID, tlvType) == JNI_TRUE);
 }
 
-JNI_METHOD(void, BaseChipCluster, setCommandTimeout)
-(JNIEnv * env, jobject self, jlong clusterPtr, jobject timeoutOptional)
+static CHIP_ERROR encodeTLVFromValue(JNIEnv * env, jobject jValue, chip::TLV::TLVWriter & writer, chip::TLV::Tag tag)
 {
-    chip::DeviceLayer::StackLock lock;
-    chip::Controller::ClusterBase * cluster = reinterpret_cast<chip::Controller::ClusterBase *>(clusterPtr);
+    jmethodID getTypeMethod  = nullptr;
+    jmethodID getValueMethod = nullptr;
+    ReturnLogErrorOnFailure(chip::JniReferences::GetInstance().FindMethod(
+        env, jValue, "type", "()Lchip/devicecontroller/ChipTLVType$TLVType;", &getTypeMethod));
 
-    jobject boxedLong = nullptr;
-    chip::JniReferences::GetInstance().GetOptionalValue(timeoutOptional, boxedLong);
+    jobject jType = env->CallObjectMethod(jValue, getTypeMethod);
+    if (jType == nullptr)
+    {
+        ChipLogError(Controller, "Error: Object to encode is corrupt");
+        return CHIP_ERROR_INVALID_ARGUMENT;
+    }
+    if (isEqualTLVType(env, "UInt", jType))
+    {
+        jclass typeClass = env->FindClass("chip/devicecontroller/ChipTLVType$UIntType");
+        VerifyOrReturnError(typeClass != nullptr, CHIP_JNI_ERROR_TYPE_NOT_FOUND);
+        getValueMethod = env->GetMethodID(typeClass, "value", "()J");
+        VerifyOrReturnError(getValueMethod != nullptr, CHIP_JNI_ERROR_METHOD_NOT_FOUND);
+
+        jlong value = env->CallLongMethod(jValue, getValueMethod);
+        VerifyOrReturnLogError(!env->ExceptionCheck(), CHIP_JNI_ERROR_EXCEPTION_THROWN);
+
+        return writer.Put(tag, static_cast<uint64_t>(value));
+    }
+    if (isEqualTLVType(env, "Int", jType))
+    {
+        jclass typeClass = env->FindClass("chip/devicecontroller/ChipTLVType$IntType");
+        VerifyOrReturnError(typeClass != nullptr, CHIP_JNI_ERROR_TYPE_NOT_FOUND);
+        getValueMethod = env->GetMethodID(typeClass, "value", "()J");
+        VerifyOrReturnError(getValueMethod != nullptr, CHIP_JNI_ERROR_METHOD_NOT_FOUND);
+
+        jlong value = env->CallLongMethod(jValue, getValueMethod);
+        VerifyOrReturnLogError(!env->ExceptionCheck(), CHIP_JNI_ERROR_EXCEPTION_THROWN);
+
+        return writer.Put(tag, static_cast<int64_t>(value));
+    }
+    if (isEqualTLVType(env, "Boolean", jType))
+    {
+        jclass typeClass = env->FindClass("chip/devicecontroller/ChipTLVType$BooleanType");
+        VerifyOrReturnError(typeClass != nullptr, CHIP_JNI_ERROR_TYPE_NOT_FOUND);
+        getValueMethod = env->GetMethodID(typeClass, "value", "()Z");
+        VerifyOrReturnError(getValueMethod != nullptr, CHIP_JNI_ERROR_METHOD_NOT_FOUND);
+
+        jboolean value = env->CallBooleanMethod(jValue, getValueMethod);
+        VerifyOrReturnLogError(!env->ExceptionCheck(), CHIP_JNI_ERROR_EXCEPTION_THROWN);
+
+        return writer.Put(tag, static_cast<bool>(value));
+    }
+    if (isEqualTLVType(env, "Float", jType))
+    {
+        jclass typeClass = env->FindClass("chip/devicecontroller/ChipTLVType$FloatType");
+        VerifyOrReturnError(typeClass != nullptr, CHIP_JNI_ERROR_TYPE_NOT_FOUND);
+        getValueMethod = env->GetMethodID(typeClass, "value", "()F");
+        VerifyOrReturnError(getValueMethod != nullptr, CHIP_JNI_ERROR_METHOD_NOT_FOUND);
 
-    if (boxedLong != nullptr)
+        jfloat value = env->CallFloatMethod(jValue, getValueMethod);
+        VerifyOrReturnLogError(!env->ExceptionCheck(), CHIP_JNI_ERROR_EXCEPTION_THROWN);
+
+        return writer.Put(tag, static_cast<float>(value));
+    }
+    if (isEqualTLVType(env, "Double", jType))
     {
-        jlong timeoutMillis = chip::JniReferences::GetInstance().LongToPrimitive(boxedLong);
-        cluster->SetCommandTimeout(chip::MakeOptional(chip::System::Clock::Milliseconds32(static_cast<uint64_t>(timeoutMillis))));
+        jclass typeClass = env->FindClass("chip/devicecontroller/ChipTLVType$DoubleType");
+        VerifyOrReturnError(typeClass != nullptr, CHIP_JNI_ERROR_TYPE_NOT_FOUND);
+        getValueMethod = env->GetMethodID(typeClass, "value", "()D");
+        VerifyOrReturnError(getValueMethod != nullptr, CHIP_JNI_ERROR_METHOD_NOT_FOUND);
+
+        jdouble value = env->CallDoubleMethod(jValue, getValueMethod);
+        VerifyOrReturnLogError(!env->ExceptionCheck(), CHIP_JNI_ERROR_EXCEPTION_THROWN);
+
+        return writer.Put(tag, static_cast<double>(value));
     }
-    else
+    if (isEqualTLVType(env, "Null", jType))
     {
-        cluster->SetCommandTimeout(chip::NullOptional);
+        return writer.PutNull(tag);
     }
+    if (isEqualTLVType(env, "String", jType))
+    {
+        jclass typeClass = env->FindClass("chip/devicecontroller/ChipTLVType$StringType");
+        VerifyOrReturnError(typeClass != nullptr, CHIP_JNI_ERROR_TYPE_NOT_FOUND);
+        getValueMethod = env->GetMethodID(typeClass, "value", "()Ljava/lang/String;");
+        VerifyOrReturnError(getValueMethod != nullptr, CHIP_JNI_ERROR_METHOD_NOT_FOUND);
+
+        jstring value = (jstring) env->CallObjectMethod(jValue, getValueMethod);
+        VerifyOrReturnLogError(!env->ExceptionCheck(), CHIP_JNI_ERROR_EXCEPTION_THROWN);
+
+        chip::JniUtfString jniString(env, value);
+
+        return writer.PutString(tag, jniString.c_str());
+    }
+    if (isEqualTLVType(env, "ByteArray", jType))
+    {
+        jclass typeClass = env->FindClass("chip/devicecontroller/ChipTLVType$ByteArrayType");
+        VerifyOrReturnError(typeClass != nullptr, CHIP_JNI_ERROR_TYPE_NOT_FOUND);
+        getValueMethod = env->GetMethodID(typeClass, "value", "()[B");
+        VerifyOrReturnError(getValueMethod != nullptr, CHIP_JNI_ERROR_METHOD_NOT_FOUND);
+
+        jbyteArray value = (jbyteArray) env->CallObjectMethod(jValue, getValueMethod);
+        VerifyOrReturnLogError(!env->ExceptionCheck(), CHIP_JNI_ERROR_EXCEPTION_THROWN);
+
+        chip::JniByteArray jniByteArray(env, value);
+
+        return writer.Put(tag, jniByteArray.byteSpan());
+    }
+    if (isEqualTLVType(env, "Struct", jType))
+    {
+        jmethodID getSizeMethod = nullptr;
+
+        jclass typeClass = env->FindClass("chip/devicecontroller/ChipTLVType$StructType");
+        VerifyOrReturnError(typeClass != nullptr, CHIP_JNI_ERROR_TYPE_NOT_FOUND);
+        getSizeMethod = env->GetMethodID(typeClass, "size", "()I");
+        VerifyOrReturnError(getSizeMethod != nullptr, CHIP_JNI_ERROR_METHOD_NOT_FOUND);
+        getValueMethod = env->GetMethodID(typeClass, "value", "(I)Lchip/devicecontroller/ChipTLVType$StructElement;");
+        VerifyOrReturnError(getValueMethod != nullptr, CHIP_JNI_ERROR_METHOD_NOT_FOUND);
+
+        jclass elementClass = env->FindClass("chip/devicecontroller/ChipTLVType$StructElement");
+        VerifyOrReturnError(elementClass != nullptr, CHIP_JNI_ERROR_TYPE_NOT_FOUND);
+        jmethodID getcontextTagNumMethod = env->GetMethodID(elementClass, "contextTagNum", "()J");
+        VerifyOrReturnError(getcontextTagNumMethod != nullptr, CHIP_JNI_ERROR_METHOD_NOT_FOUND);
+        jmethodID getElementValueMethod =
+            env->GetMethodID(elementClass, "value", "()Lchip/devicecontroller/ChipTLVType$BaseTLVType;");
+        VerifyOrReturnError(getElementValueMethod != nullptr, CHIP_JNI_ERROR_METHOD_NOT_FOUND);
+
+        jint size = env->CallIntMethod(jValue, getSizeMethod);
+        VerifyOrReturnLogError(!env->ExceptionCheck(), CHIP_JNI_ERROR_EXCEPTION_THROWN);
+
+        chip::TLV::TLVType outer;
+        ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Structure, outer));
+        for (int i = 0; i < static_cast<int>(size); i++)
+        {
+            jobject eachElement = env->CallObjectMethod(jValue, getValueMethod, static_cast<jint>(i));
+            VerifyOrReturnLogError(!env->ExceptionCheck(), CHIP_JNI_ERROR_EXCEPTION_THROWN);
+
+            jlong jEachTag = env->CallLongMethod(eachElement, getcontextTagNumMethod);
+            VerifyOrReturnLogError(!env->ExceptionCheck(), CHIP_JNI_ERROR_EXCEPTION_THROWN);
+
+            jobject jEachValue = env->CallObjectMethod(eachElement, getElementValueMethod);
+            VerifyOrReturnLogError(!env->ExceptionCheck(), CHIP_JNI_ERROR_EXCEPTION_THROWN);
+
+            uint64_t tagValue       = static_cast<uint64_t>(jEachTag);
+            chip::TLV::Tag innerTag = chip::TLV::ContextTag(static_cast<uint8_t>(tagValue));
+            ReturnErrorOnFailure(encodeTLVFromValue(env, jEachValue, writer, innerTag));
+        }
+        ReturnErrorOnFailure(writer.EndContainer(outer));
+        return CHIP_NO_ERROR;
+    }
+    if (isEqualTLVType(env, "Array", jType))
+    {
+        jmethodID getSizeMethod = nullptr;
+
+        jclass typeClass = env->FindClass("chip/devicecontroller/ChipTLVType$ArrayType");
+        VerifyOrReturnError(typeClass != nullptr, CHIP_JNI_ERROR_TYPE_NOT_FOUND);
+
+        getSizeMethod = env->GetMethodID(typeClass, "size", "()I");
+        VerifyOrReturnError(getSizeMethod != nullptr, CHIP_JNI_ERROR_METHOD_NOT_FOUND);
+        getValueMethod = env->GetMethodID(typeClass, "value", "(I)Lchip/devicecontroller/ChipTLVType$BaseTLVType;");
+        VerifyOrReturnError(getValueMethod != nullptr, CHIP_JNI_ERROR_METHOD_NOT_FOUND);
+
+        jint size = env->CallIntMethod(jValue, getSizeMethod);
+        VerifyOrReturnLogError(!env->ExceptionCheck(), CHIP_JNI_ERROR_EXCEPTION_THROWN);
+
+        chip::TLV::TLVType outer;
+        ReturnErrorOnFailure(writer.StartContainer(tag, chip::TLV::kTLVType_Array, outer));
+        for (int i = 0; i < static_cast<int>(size); i++)
+        {
+            jobject eachValue = env->CallObjectMethod(jValue, getValueMethod, static_cast<jint>(i));
+            VerifyOrReturnLogError(!env->ExceptionCheck(), CHIP_JNI_ERROR_EXCEPTION_THROWN);
+
+            ReturnErrorOnFailure(encodeTLVFromValue(env, eachValue, writer, chip::TLV::AnonymousTag()));
+        }
+        ReturnErrorOnFailure(writer.EndContainer(outer));
+        return CHIP_NO_ERROR;
+    }
+    if (isEqualTLVType(env, "Empty", jType))
+    {
+        // For optional Value
+        return CHIP_NO_ERROR;
+    }
+
+    ChipLogError(Controller, "Error: Unsupported type to encode");
+    return CHIP_ERROR_INVALID_ARGUMENT;
+}
+
+JNI_METHOD(jbyteArray, BaseChipCluster, encodeToTlv)(JNIEnv * env, jclass clazz, jobject value)
+{
+    VerifyOrReturnValue(value != nullptr, nullptr, ChipLogError(Controller, "invalid parameter: value is null"));
+    chip::TLV::TLVWriter writer;
+    uint8_t buffer[CHIP_TLV_WRITER_BUFFER_SIZE];
+    jbyteArray tlv = nullptr;
+    writer.Init(buffer, sizeof(buffer));
+
+    CHIP_ERROR err = encodeTLVFromValue(env, value, writer, chip::TLV::AnonymousTag());
+    VerifyOrReturnValue(err == CHIP_NO_ERROR, nullptr, ChipLogError(Controller, "Encode Error: %" CHIP_ERROR_FORMAT, err.Format()));
+
+    err = chip::JniReferences::GetInstance().N2J_ByteArray(env, buffer, writer.GetLengthWritten(), tlv);
+    VerifyOrReturnValue(err == CHIP_NO_ERROR, nullptr, ChipLogError(Controller, "JNI Error: %" CHIP_ERROR_FORMAT, err.Format()));
+
+    return tlv;
+}
+
+JNI_METHOD(jobject, BaseChipCluster, decodeFromTlv)(JNIEnv * env, jclass clazz, jbyteArray tlvBytesObj)
+{
+    VerifyOrReturnValue(tlvBytesObj != nullptr, nullptr, ChipLogError(Controller, "invalid parameter: tlvBytesObj is null"));
+    chip::JniByteArray tlvBytesObjBytes(env, tlvBytesObj);
+
+    chip::TLV::TLVReader reader;
+    reader.Init(tlvBytesObjBytes.byteSpan());
+    VerifyOrReturnValue(reader.Next() == CHIP_NO_ERROR, nullptr, ChipLogError(Controller, "TLV Parsing is wrong"));
+
+    return decodeValueFromTLV(env, &reader);
 }
diff --git a/src/controller/java/CHIPDeviceController-JNI.cpp b/src/controller/java/CHIPDeviceController-JNI.cpp
index a7443852d8a678..7633b0a304d793 100644
--- a/src/controller/java/CHIPDeviceController-JNI.cpp
+++ b/src/controller/java/CHIPDeviceController-JNI.cpp
@@ -2092,7 +2092,7 @@ JNI_METHOD(jobject, computePaseVerifier)
 }
 
 JNI_METHOD(void, subscribe)
-(JNIEnv * env, jobject self, jlong handle, jlong callbackHandle, jlong devicePtr, jobject attributePathList, jobject eventPathList,
+(JNIEnv * env, jclass clz, jlong handle, jlong callbackHandle, jlong devicePtr, jobject attributePathList, jobject eventPathList,
  jint minInterval, jint maxInterval, jboolean keepSubscriptions, jboolean isFabricFiltered, jint imTimeoutMs, jobject eventMin)
 {
     chip::DeviceLayer::StackLock lock;
@@ -2201,7 +2201,7 @@ JNI_METHOD(void, subscribe)
 }
 
 JNI_METHOD(void, read)
-(JNIEnv * env, jobject self, jlong handle, jlong callbackHandle, jlong devicePtr, jobject attributePathList, jobject eventPathList,
+(JNIEnv * env, jclass clz, jlong handle, jlong callbackHandle, jlong devicePtr, jobject attributePathList, jobject eventPathList,
  jboolean isFabricFiltered, jint imTimeoutMs, jobject eventMin)
 {
     chip::DeviceLayer::StackLock lock;
@@ -2295,7 +2295,7 @@ CHIP_ERROR PutPreencodedWriteAttribute(app::WriteClient & writeClient, app::Conc
 }
 
 JNI_METHOD(void, write)
-(JNIEnv * env, jobject self, jlong handle, jlong callbackHandle, jlong devicePtr, jobject attributeList, jint timedRequestTimeoutMs,
+(JNIEnv * env, jclass clz, jlong handle, jlong callbackHandle, jlong devicePtr, jobject attributeList, jint timedRequestTimeoutMs,
  jint imTimeoutMs)
 {
     chip::DeviceLayer::StackLock lock;
@@ -2461,7 +2461,7 @@ CHIP_ERROR PutPreencodedInvokeRequest(app::CommandSender & commandSender, app::C
 }
 
 JNI_METHOD(void, invoke)
-(JNIEnv * env, jobject self, jlong handle, jlong callbackHandle, jlong devicePtr, jobject invokeElement, jint timedRequestTimeoutMs,
+(JNIEnv * env, jclass clz, jlong handle, jlong callbackHandle, jlong devicePtr, jobject invokeElement, jint timedRequestTimeoutMs,
  jint imTimeoutMs)
 {
     chip::DeviceLayer::StackLock lock;
diff --git a/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java b/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java
index 0a5f12d8c14f1f..f93816af07f301 100644
--- a/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java
+++ b/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java
@@ -17,68 +17,84 @@
 
 package chip.devicecontroller;
 
+import chip.devicecontroller.model.AttributeState;
+import chip.devicecontroller.model.AttributeWriteRequest;
+import chip.devicecontroller.model.ChipAttributePath;
+import chip.devicecontroller.model.ChipEventPath;
+import chip.devicecontroller.model.ClusterState;
+import chip.devicecontroller.model.EndpointState;
+import chip.devicecontroller.model.InvokeElement;
+import chip.devicecontroller.model.NodeState;
+
 import javax.annotation.Nullable;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Optional;
 
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import static chip.devicecontroller.ChipTLVType.*;
+
 public class ChipClusters {
 
-  public interface DefaultClusterCallback {
+  public interface BaseClusterCallback {
+    void onError(Exception error);
+  }
+
+  public interface DefaultClusterCallback extends BaseClusterCallback {
     void onSuccess();
+  }
+
+  public interface BaseAttributeCallback {
     void onError(Exception error);
+    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
-  public interface CharStringAttributeCallback {
+  public interface CharStringAttributeCallback extends BaseAttributeCallback {
     /** Indicates a successful read for a CHAR_STRING attribute. */
     void onSuccess(String value);
-    void onError(Exception error);
-    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
-  public interface OctetStringAttributeCallback {
+  public interface OctetStringAttributeCallback extends BaseAttributeCallback {
     /** Indicates a successful read for an OCTET_STRING attribute. */
     void onSuccess(byte[] value);
-    void onError(Exception error);
-    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
-  public interface IntegerAttributeCallback {
+  public interface IntegerAttributeCallback extends BaseAttributeCallback {
     void onSuccess(int value);
-    void onError(Exception error);
-    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
-  public interface LongAttributeCallback {
+  public interface LongAttributeCallback extends BaseAttributeCallback {
     void onSuccess(long value);
-    void onError(Exception error);
-    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
-  public interface BooleanAttributeCallback {
+  public interface BooleanAttributeCallback extends BaseAttributeCallback {
     void onSuccess(boolean value);
-    void onError(Exception error);
-    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
-  public interface FloatAttributeCallback {
+  public interface FloatAttributeCallback extends BaseAttributeCallback {
     void onSuccess(float value);
-    void onError(Exception error);
-    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
-  public interface DoubleAttributeCallback {
+  public interface DoubleAttributeCallback extends BaseAttributeCallback {
     void onSuccess(double value);
-    void onError(Exception error);
-    default void onSubscriptionEstablished(long subscriptionId) {}
   }
 
   public static abstract class BaseChipCluster {
     protected long chipClusterPtr;
 
-    public BaseChipCluster(long devicePtr, int endpointId) {
-      chipClusterPtr = initWithDevice(devicePtr, endpointId);
+    protected long devicePtr;
+    protected int endpointId;
+    protected long clusterId;
+
+    private Optional<Long> timeoutMillis = Optional.empty();
+
+    public BaseChipCluster(long devicePtr, int endpointId, long clusterId) {
+      this.devicePtr = devicePtr;
+      this.endpointId = endpointId;
+      this.clusterId = clusterId;
     }
 
     /**
@@ -87,22 +103,64 @@ public BaseChipCluster(long devicePtr, int endpointId) {
      * empty optional, the default timeout will be used.
      */
     public void setCommandTimeout(Optional<Long> timeoutMillis) {
-      setCommandTimeout(chipClusterPtr, timeoutMillis);
+      this.timeoutMillis = timeoutMillis;
     }
 
-    private native void setCommandTimeout(long clusterPtr, Optional<Long> timeoutMillis);
-
     /** Returns the current timeout (in milliseconds) for commands sent through this cluster. */
     public Optional<Long> getCommandTimeout() {
-      Optional<Long> timeout = getCommandTimeout(chipClusterPtr);
-      return timeout == null ? Optional.empty() : timeout;
+      return timeoutMillis == null ? Optional.empty() : timeoutMillis;
     }
 
-    private native Optional<Long> getCommandTimeout(long clusterPtr);
-
+    @Deprecated
     public abstract long initWithDevice(long devicePtr, int endpointId);
 
-    public native void deleteCluster(long chipClusterPtr);
+    protected void readAttribute(
+        ReportCallbackImpl callback,
+        long attributeId,
+        boolean isFabricFiltered) {
+      ReportCallbackJni jniCallback = new ReportCallbackJni(null, callback, null);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, attributeId);
+      ChipDeviceController.read(0, jniCallback.getCallbackHandle(), devicePtr, Arrays.asList(path), null, isFabricFiltered, timeoutMillis.orElse(0L).intValue(), null);
+    }
+
+    protected void writeAttribute(
+        WriteAttributesCallbackImpl callback,
+        long attributeId,
+        BaseTLVType value,
+        int timedRequestTimeoutMs) {
+      WriteAttributesCallbackJni jniCallback = new WriteAttributesCallbackJni(callback);
+      byte[] tlv = encodeToTlv(value);
+      AttributeWriteRequest writeRequest = AttributeWriteRequest.newInstance(endpointId, clusterId, attributeId, tlv);
+      ChipDeviceController.write(0, jniCallback.getCallbackHandle(), devicePtr, Arrays.asList(writeRequest), timedRequestTimeoutMs, timeoutMillis.orElse(0L).intValue());
+    }
+
+    protected void subscribeAttribute(
+        ReportCallbackImpl callback,
+        long attributeId,
+        int minInterval,
+        int maxInterval) {
+      ReportCallbackJni jniCallback = new ReportCallbackJni(callback, callback, null);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, attributeId);
+      ChipDeviceController.subscribe(0, jniCallback.getCallbackHandle(), devicePtr, Arrays.asList(path), null, minInterval, maxInterval, false, true, timeoutMillis.orElse(0L).intValue(), null);
+    }
+
+    protected void invoke(
+        InvokeCallbackImpl callback,
+        long commandId,
+        BaseTLVType value,
+        int timedRequestTimeoutMs) {
+      InvokeCallbackJni jniCallback = new InvokeCallbackJni(callback);
+      byte[] tlv = encodeToTlv(value);
+      InvokeElement element = InvokeElement.newInstance(endpointId, clusterId, commandId, tlv, null);
+      ChipDeviceController.invoke(0, jniCallback.getCallbackHandle(), devicePtr, element, timedRequestTimeoutMs, timeoutMillis.orElse(0L).intValue());
+    }
+
+    private static native byte[] encodeToTlv(BaseTLVType value);
+
+    static native BaseTLVType decodeFromTlv(byte[] tlv);
+
+    @Deprecated
+    public void deleteCluster(long chipClusterPtr) {}
     
     @SuppressWarnings("deprecation")
     protected void finalize() throws Throwable {
@@ -115,32519 +173,55389 @@ protected void finalize() throws Throwable {
     }
   }
 
+  abstract static class ReportCallbackImpl implements ReportCallback, SubscriptionEstablishedCallback {
+    private BaseAttributeCallback callback;
+    private ChipAttributePath path;
+
+    private static final long CHIP_ERROR_UNSUPPORTED_ATTRIBUTE = 0x86;
+
+    ReportCallbackImpl(BaseAttributeCallback callback, ChipAttributePath path) {
+      this.callback = callback;
+      this.path = path;
+    }
+
+    @Override
+    public void onError(
+        @Nullable ChipAttributePath attributePath,
+        @Nullable ChipEventPath eventPath,
+        @Nonnull Exception e) {
+      callback.onError(e);
+    }
+
+    @Override
+    public void onReport(NodeState nodeState) {
+      if (nodeState == null) {
+        callback.onError(new ChipClusterException());
+        return;
+      }
+
+      EndpointState endpointState = nodeState.getEndpointState((int)path.getEndpointId().getId());
+      if (endpointState == null) {
+        callback.onError(new ChipClusterException(CHIP_ERROR_UNSUPPORTED_ATTRIBUTE));
+        return;
+      }
+
+      ClusterState clusterState = endpointState.getClusterState(path.getClusterId().getId());
+      if (clusterState == null) {
+        callback.onError(new ChipClusterException(CHIP_ERROR_UNSUPPORTED_ATTRIBUTE));
+        return;
+      }
+
+      AttributeState attributeState = clusterState.getAttributeState(path.getAttributeId().getId());
+      if (attributeState == null) {
+        callback.onError(new ChipClusterException(CHIP_ERROR_UNSUPPORTED_ATTRIBUTE));
+        return;
+      }
+
+      byte[] tlv = attributeState.getTlv();
+      if (tlv == null) {
+          callback.onError(new ChipClusterException(CHIP_ERROR_UNSUPPORTED_ATTRIBUTE));
+          return;
+      }
+
+      onSuccess(tlv);
+    }
+
+    @Override
+    public void onSubscriptionEstablished(long subscriptionId) {
+      callback.onSubscriptionEstablished(subscriptionId);
+    }
+
+    public abstract void onSuccess(byte[] tlv);
+  }
+
+  static class WriteAttributesCallbackImpl implements WriteAttributesCallback {
+    private DefaultClusterCallback callback;
+
+    WriteAttributesCallbackImpl(DefaultClusterCallback callback) {
+      this.callback = callback;
+    }
+
+    @Override
+    public void onResponse(ChipAttributePath attributePath) {
+      callback.onSuccess();
+    }
+
+    @Override
+    public void onError(@Nullable ChipAttributePath attributePath, Exception e) {
+      callback.onError(e);
+    }
+  }
+
+  abstract static class InvokeCallbackImpl implements InvokeCallback {
+    private BaseClusterCallback callback;
+
+    private static final long CHIP_ERROR_UNSUPPORTED_COMMAND = 0x81;
+
+    InvokeCallbackImpl(BaseClusterCallback callback) {
+      this.callback = callback;
+    }
+
+    public void onError(Exception e) {
+      callback.onError(e);
+    }
+
+    public void onResponse(InvokeElement invokeElement, long successCode) {
+      byte[] tlv = invokeElement.getTlvByteArray();
+      if (tlv == null) {
+        onResponse(null);
+        return;
+      }
+      BaseTLVType value = BaseChipCluster.decodeFromTlv(tlv);
+      if (value == null || value.type() != TLVType.Struct) {
+        callback.onError(new ChipClusterException(CHIP_ERROR_UNSUPPORTED_COMMAND));
+        return;
+      }
+      onResponse((StructType)value);
+    }
+
+    public abstract void onResponse(StructType value);
+  }
+
   public static class IdentifyCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 3L;
 
+    private static final long IDENTIFY_TIME_ATTRIBUTE_ID = 0L;
+    private static final long IDENTIFY_TYPE_ATTRIBUTE_ID = 1L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public IdentifyCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void identify(DefaultClusterCallback callback, Integer identifyTime) {
-      identify(chipClusterPtr, callback, identifyTime, null);
+      identify(callback, identifyTime, 0);
     }
 
     public void identify(DefaultClusterCallback callback, Integer identifyTime, int timedInvokeTimeoutMs) {
-      identify(chipClusterPtr, callback, identifyTime, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long identifyTimeFieldID = 0L;
+      BaseTLVType identifyTimetlvValue = new UIntType(identifyTime);
+      elements.add(new StructElement(identifyTimeFieldID, identifyTimetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void triggerEffect(DefaultClusterCallback callback, Integer effectIdentifier, Integer effectVariant) {
-      triggerEffect(chipClusterPtr, callback, effectIdentifier, effectVariant, null);
+      triggerEffect(callback, effectIdentifier, effectVariant, 0);
     }
 
     public void triggerEffect(DefaultClusterCallback callback, Integer effectIdentifier, Integer effectVariant, int timedInvokeTimeoutMs) {
-      triggerEffect(chipClusterPtr, callback, effectIdentifier, effectVariant, timedInvokeTimeoutMs);
-    }
+      final long commandId = 64L;
 
-    private native void identify(long chipClusterPtr, DefaultClusterCallback callback, Integer identifyTime, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long effectIdentifierFieldID = 0L;
+      BaseTLVType effectIdentifiertlvValue = new UIntType(effectIdentifier);
+      elements.add(new StructElement(effectIdentifierFieldID, effectIdentifiertlvValue));
 
-    private native void triggerEffect(long chipClusterPtr, DefaultClusterCallback callback, Integer effectIdentifier, Integer effectVariant, @Nullable Integer timedInvokeTimeoutMs);
+      final long effectVariantFieldID = 1L;
+      BaseTLVType effectVarianttlvValue = new UIntType(effectVariant);
+      elements.add(new StructElement(effectVariantFieldID, effectVarianttlvValue));
 
-    public interface GeneratedCommandListAttributeCallback {
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readIdentifyTimeAttribute(
         IntegerAttributeCallback callback) {
-        readIdentifyTimeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, IDENTIFY_TIME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, IDENTIFY_TIME_ATTRIBUTE_ID, true);
     }
 
     public void writeIdentifyTimeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeIdentifyTimeAttribute(chipClusterPtr, callback, value, null);
+      writeIdentifyTimeAttribute(callback, value, 0);
     }
 
     public void writeIdentifyTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeIdentifyTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), IDENTIFY_TIME_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeIdentifyTimeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeIdentifyTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, IDENTIFY_TIME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, IDENTIFY_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readIdentifyTypeAttribute(
         IntegerAttributeCallback callback) {
-        readIdentifyTypeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, IDENTIFY_TYPE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, IDENTIFY_TYPE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeIdentifyTypeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeIdentifyTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, IDENTIFY_TYPE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, IDENTIFY_TYPE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    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);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class GroupsCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 4L;
 
+    private static final long NAME_SUPPORT_ATTRIBUTE_ID = 0L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public GroupsCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void addGroup(AddGroupResponseCallback callback, Integer groupID, String groupName) {
-      addGroup(chipClusterPtr, callback, groupID, groupName, null);
+      addGroup(callback, groupID, groupName, 0);
     }
 
     public void addGroup(AddGroupResponseCallback callback, Integer groupID, String groupName, int timedInvokeTimeoutMs) {
-      addGroup(chipClusterPtr, callback, groupID, groupName, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long groupIDFieldID = 0L;
+      BaseTLVType groupIDtlvValue = new UIntType(groupID);
+      elements.add(new StructElement(groupIDFieldID, groupIDtlvValue));
+
+      final long groupNameFieldID = 1L;
+      BaseTLVType groupNametlvValue = new StringType(groupName);
+      elements.add(new StructElement(groupNameFieldID, groupNametlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long groupIDFieldID = 1L;
+          Integer groupID = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == groupIDFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                groupID = castingValue.value(Integer.class);
+              }
+            }
+          }
+          callback.onSuccess(status, groupID);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void viewGroup(ViewGroupResponseCallback callback, Integer groupID) {
-      viewGroup(chipClusterPtr, callback, groupID, null);
+      viewGroup(callback, groupID, 0);
     }
 
     public void viewGroup(ViewGroupResponseCallback callback, Integer groupID, int timedInvokeTimeoutMs) {
-      viewGroup(chipClusterPtr, callback, groupID, timedInvokeTimeoutMs);
+      final long commandId = 1L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long groupIDFieldID = 0L;
+      BaseTLVType groupIDtlvValue = new UIntType(groupID);
+      elements.add(new StructElement(groupIDFieldID, groupIDtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long groupIDFieldID = 1L;
+          Integer groupID = null;
+          final long groupNameFieldID = 2L;
+          String groupName = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == groupIDFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                groupID = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == groupNameFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                groupName = castingValue.value(String.class);
+              }
+            }
+          }
+          callback.onSuccess(status, groupID, groupName);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void getGroupMembership(GetGroupMembershipResponseCallback callback, ArrayList<Integer> groupList) {
-      getGroupMembership(chipClusterPtr, callback, groupList, null);
+      getGroupMembership(callback, groupList, 0);
     }
 
     public void getGroupMembership(GetGroupMembershipResponseCallback callback, ArrayList<Integer> groupList, int timedInvokeTimeoutMs) {
-      getGroupMembership(chipClusterPtr, callback, groupList, timedInvokeTimeoutMs);
+      final long commandId = 2L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long groupListFieldID = 0L;
+      BaseTLVType groupListtlvValue = ArrayType.generateArrayType(groupList, (elementgroupList) -> new UIntType(elementgroupList));
+      elements.add(new StructElement(groupListFieldID, groupListtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long capacityFieldID = 0L;
+          @Nullable Integer capacity = null;
+          final long groupListFieldID = 1L;
+          ArrayList<Integer> groupList = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == capacityFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                capacity = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == groupListFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+                ArrayType castingValue = element.value(ArrayType.class);
+                groupList = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+              }
+            }
+          }
+          callback.onSuccess(capacity, groupList);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void removeGroup(RemoveGroupResponseCallback callback, Integer groupID) {
-      removeGroup(chipClusterPtr, callback, groupID, null);
+      removeGroup(callback, groupID, 0);
     }
 
     public void removeGroup(RemoveGroupResponseCallback callback, Integer groupID, int timedInvokeTimeoutMs) {
-      removeGroup(chipClusterPtr, callback, groupID, timedInvokeTimeoutMs);
+      final long commandId = 3L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long groupIDFieldID = 0L;
+      BaseTLVType groupIDtlvValue = new UIntType(groupID);
+      elements.add(new StructElement(groupIDFieldID, groupIDtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long groupIDFieldID = 1L;
+          Integer groupID = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == groupIDFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                groupID = castingValue.value(Integer.class);
+              }
+            }
+          }
+          callback.onSuccess(status, groupID);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void removeAllGroups(DefaultClusterCallback callback) {
-      removeAllGroups(chipClusterPtr, callback, null);
+      removeAllGroups(callback, 0);
     }
 
     public void removeAllGroups(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      removeAllGroups(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 4L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void addGroupIfIdentifying(DefaultClusterCallback callback, Integer groupID, String groupName) {
-      addGroupIfIdentifying(chipClusterPtr, callback, groupID, groupName, null);
+      addGroupIfIdentifying(callback, groupID, groupName, 0);
     }
 
     public void addGroupIfIdentifying(DefaultClusterCallback callback, Integer groupID, String groupName, int timedInvokeTimeoutMs) {
-      addGroupIfIdentifying(chipClusterPtr, callback, groupID, groupName, timedInvokeTimeoutMs);
-    }
-
-    private native void addGroup(long chipClusterPtr, AddGroupResponseCallback callback, Integer groupID, String groupName, @Nullable Integer timedInvokeTimeoutMs);
+      final long commandId = 5L;
 
-    private native void viewGroup(long chipClusterPtr, ViewGroupResponseCallback callback, Integer groupID, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long groupIDFieldID = 0L;
+      BaseTLVType groupIDtlvValue = new UIntType(groupID);
+      elements.add(new StructElement(groupIDFieldID, groupIDtlvValue));
 
-    private native void getGroupMembership(long chipClusterPtr, GetGroupMembershipResponseCallback callback, ArrayList<Integer> groupList, @Nullable Integer timedInvokeTimeoutMs);
+      final long groupNameFieldID = 1L;
+      BaseTLVType groupNametlvValue = new StringType(groupName);
+      elements.add(new StructElement(groupNameFieldID, groupNametlvValue));
 
-    private native void removeGroup(long chipClusterPtr, RemoveGroupResponseCallback callback, Integer groupID, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void removeAllGroups(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void addGroupIfIdentifying(long chipClusterPtr, DefaultClusterCallback callback, Integer groupID, String groupName, @Nullable Integer timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface AddGroupResponseCallback {
+    public interface AddGroupResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, Integer groupID);
-      void onError(Exception error);
     }
 
-    public interface ViewGroupResponseCallback {
+    public interface ViewGroupResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, Integer groupID, String groupName);
-      void onError(Exception error);
     }
 
-    public interface GetGroupMembershipResponseCallback {
+    public interface GetGroupMembershipResponseCallback extends BaseClusterCallback {
       void onSuccess(@Nullable Integer capacity, ArrayList<Integer> groupList);
-      void onError(Exception error);
     }
 
-    public interface RemoveGroupResponseCallback {
+    public interface RemoveGroupResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, Integer groupID);
-      void onError(Exception error);
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readNameSupportAttribute(
         IntegerAttributeCallback callback) {
-        readNameSupportAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NAME_SUPPORT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NAME_SUPPORT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeNameSupportAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNameSupportAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NAME_SUPPORT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NAME_SUPPORT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class ScenesCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 5L;
 
+    private static final long SCENE_COUNT_ATTRIBUTE_ID = 0L;
+    private static final long CURRENT_SCENE_ATTRIBUTE_ID = 1L;
+    private static final long CURRENT_GROUP_ATTRIBUTE_ID = 2L;
+    private static final long SCENE_VALID_ATTRIBUTE_ID = 3L;
+    private static final long NAME_SUPPORT_ATTRIBUTE_ID = 4L;
+    private static final long LAST_CONFIGURED_BY_ATTRIBUTE_ID = 5L;
+    private static final long SCENE_TABLE_SIZE_ATTRIBUTE_ID = 6L;
+    private static final long REMAINING_CAPACITY_ATTRIBUTE_ID = 7L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public ScenesCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void addScene(AddSceneResponseCallback callback, Integer groupID, Integer sceneID, Integer transitionTime, String sceneName, ArrayList<ChipStructs.ScenesClusterExtensionFieldSet> extensionFieldSets) {
-      addScene(chipClusterPtr, callback, groupID, sceneID, transitionTime, sceneName, extensionFieldSets, null);
+      addScene(callback, groupID, sceneID, transitionTime, sceneName, extensionFieldSets, 0);
     }
 
     public void addScene(AddSceneResponseCallback callback, Integer groupID, Integer sceneID, Integer transitionTime, String sceneName, ArrayList<ChipStructs.ScenesClusterExtensionFieldSet> extensionFieldSets, int timedInvokeTimeoutMs) {
-      addScene(chipClusterPtr, callback, groupID, sceneID, transitionTime, sceneName, extensionFieldSets, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long groupIDFieldID = 0L;
+      BaseTLVType groupIDtlvValue = new UIntType(groupID);
+      elements.add(new StructElement(groupIDFieldID, groupIDtlvValue));
+
+      final long sceneIDFieldID = 1L;
+      BaseTLVType sceneIDtlvValue = new UIntType(sceneID);
+      elements.add(new StructElement(sceneIDFieldID, sceneIDtlvValue));
+
+      final long transitionTimeFieldID = 2L;
+      BaseTLVType transitionTimetlvValue = new UIntType(transitionTime);
+      elements.add(new StructElement(transitionTimeFieldID, transitionTimetlvValue));
+
+      final long sceneNameFieldID = 3L;
+      BaseTLVType sceneNametlvValue = new StringType(sceneName);
+      elements.add(new StructElement(sceneNameFieldID, sceneNametlvValue));
+
+      final long extensionFieldSetsFieldID = 4L;
+      BaseTLVType extensionFieldSetstlvValue = ArrayType.generateArrayType(extensionFieldSets, (elementextensionFieldSets) -> elementextensionFieldSets.encodeTlv());
+      elements.add(new StructElement(extensionFieldSetsFieldID, extensionFieldSetstlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long groupIDFieldID = 1L;
+          Integer groupID = null;
+          final long sceneIDFieldID = 2L;
+          Integer sceneID = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == groupIDFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                groupID = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == sceneIDFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                sceneID = castingValue.value(Integer.class);
+              }
+            }
+          }
+          callback.onSuccess(status, groupID, sceneID);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void viewScene(ViewSceneResponseCallback callback, Integer groupID, Integer sceneID) {
-      viewScene(chipClusterPtr, callback, groupID, sceneID, null);
+      viewScene(callback, groupID, sceneID, 0);
     }
 
     public void viewScene(ViewSceneResponseCallback callback, Integer groupID, Integer sceneID, int timedInvokeTimeoutMs) {
-      viewScene(chipClusterPtr, callback, groupID, sceneID, timedInvokeTimeoutMs);
+      final long commandId = 1L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long groupIDFieldID = 0L;
+      BaseTLVType groupIDtlvValue = new UIntType(groupID);
+      elements.add(new StructElement(groupIDFieldID, groupIDtlvValue));
+
+      final long sceneIDFieldID = 1L;
+      BaseTLVType sceneIDtlvValue = new UIntType(sceneID);
+      elements.add(new StructElement(sceneIDFieldID, sceneIDtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long groupIDFieldID = 1L;
+          Integer groupID = null;
+          final long sceneIDFieldID = 2L;
+          Integer sceneID = null;
+          final long transitionTimeFieldID = 3L;
+          Optional<Integer> transitionTime = Optional.empty();
+          final long sceneNameFieldID = 4L;
+          Optional<String> sceneName = Optional.empty();
+          final long extensionFieldSetsFieldID = 5L;
+          Optional<ArrayList<ChipStructs.ScenesClusterExtensionFieldSet>> extensionFieldSets = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == groupIDFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                groupID = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == sceneIDFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                sceneID = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == transitionTimeFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                transitionTime = Optional.of(castingValue.value(Integer.class));
+              }
+            } else if (element.contextTagNum() == sceneNameFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                sceneName = Optional.of(castingValue.value(String.class));
+              }
+            } else if (element.contextTagNum() == extensionFieldSetsFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+                ArrayType castingValue = element.value(ArrayType.class);
+                extensionFieldSets = Optional.of(castingValue.map((elementcastingValue) -> ChipStructs.ScenesClusterExtensionFieldSet.decodeTlv(elementcastingValue)));
+              }
+            }
+          }
+          callback.onSuccess(status, groupID, sceneID, transitionTime, sceneName, extensionFieldSets);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void removeScene(RemoveSceneResponseCallback callback, Integer groupID, Integer sceneID) {
-      removeScene(chipClusterPtr, callback, groupID, sceneID, null);
+      removeScene(callback, groupID, sceneID, 0);
     }
 
     public void removeScene(RemoveSceneResponseCallback callback, Integer groupID, Integer sceneID, int timedInvokeTimeoutMs) {
-      removeScene(chipClusterPtr, callback, groupID, sceneID, timedInvokeTimeoutMs);
+      final long commandId = 2L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long groupIDFieldID = 0L;
+      BaseTLVType groupIDtlvValue = new UIntType(groupID);
+      elements.add(new StructElement(groupIDFieldID, groupIDtlvValue));
+
+      final long sceneIDFieldID = 1L;
+      BaseTLVType sceneIDtlvValue = new UIntType(sceneID);
+      elements.add(new StructElement(sceneIDFieldID, sceneIDtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long groupIDFieldID = 1L;
+          Integer groupID = null;
+          final long sceneIDFieldID = 2L;
+          Integer sceneID = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == groupIDFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                groupID = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == sceneIDFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                sceneID = castingValue.value(Integer.class);
+              }
+            }
+          }
+          callback.onSuccess(status, groupID, sceneID);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void removeAllScenes(RemoveAllScenesResponseCallback callback, Integer groupID) {
-      removeAllScenes(chipClusterPtr, callback, groupID, null);
+      removeAllScenes(callback, groupID, 0);
     }
 
     public void removeAllScenes(RemoveAllScenesResponseCallback callback, Integer groupID, int timedInvokeTimeoutMs) {
-      removeAllScenes(chipClusterPtr, callback, groupID, timedInvokeTimeoutMs);
+      final long commandId = 3L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long groupIDFieldID = 0L;
+      BaseTLVType groupIDtlvValue = new UIntType(groupID);
+      elements.add(new StructElement(groupIDFieldID, groupIDtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long groupIDFieldID = 1L;
+          Integer groupID = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == groupIDFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                groupID = castingValue.value(Integer.class);
+              }
+            }
+          }
+          callback.onSuccess(status, groupID);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void storeScene(StoreSceneResponseCallback callback, Integer groupID, Integer sceneID) {
-      storeScene(chipClusterPtr, callback, groupID, sceneID, null);
+      storeScene(callback, groupID, sceneID, 0);
     }
 
     public void storeScene(StoreSceneResponseCallback callback, Integer groupID, Integer sceneID, int timedInvokeTimeoutMs) {
-      storeScene(chipClusterPtr, callback, groupID, sceneID, timedInvokeTimeoutMs);
+      final long commandId = 4L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long groupIDFieldID = 0L;
+      BaseTLVType groupIDtlvValue = new UIntType(groupID);
+      elements.add(new StructElement(groupIDFieldID, groupIDtlvValue));
+
+      final long sceneIDFieldID = 1L;
+      BaseTLVType sceneIDtlvValue = new UIntType(sceneID);
+      elements.add(new StructElement(sceneIDFieldID, sceneIDtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long groupIDFieldID = 1L;
+          Integer groupID = null;
+          final long sceneIDFieldID = 2L;
+          Integer sceneID = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == groupIDFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                groupID = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == sceneIDFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                sceneID = castingValue.value(Integer.class);
+              }
+            }
+          }
+          callback.onSuccess(status, groupID, sceneID);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void recallScene(DefaultClusterCallback callback, Integer groupID, Integer sceneID, @Nullable Optional<Integer> transitionTime) {
-      recallScene(chipClusterPtr, callback, groupID, sceneID, transitionTime, null);
+      recallScene(callback, groupID, sceneID, transitionTime, 0);
     }
 
     public void recallScene(DefaultClusterCallback callback, Integer groupID, Integer sceneID, @Nullable Optional<Integer> transitionTime, int timedInvokeTimeoutMs) {
-      recallScene(chipClusterPtr, callback, groupID, sceneID, transitionTime, timedInvokeTimeoutMs);
+      final long commandId = 5L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long groupIDFieldID = 0L;
+      BaseTLVType groupIDtlvValue = new UIntType(groupID);
+      elements.add(new StructElement(groupIDFieldID, groupIDtlvValue));
+
+      final long sceneIDFieldID = 1L;
+      BaseTLVType sceneIDtlvValue = new UIntType(sceneID);
+      elements.add(new StructElement(sceneIDFieldID, sceneIDtlvValue));
+
+      final long transitionTimeFieldID = 2L;
+      BaseTLVType transitionTimetlvValue = transitionTime != null ? transitionTime.<BaseTLVType>map((nonOptionaltransitionTime) -> new UIntType(nonOptionaltransitionTime)).orElse(new EmptyType()) : new NullType();
+      elements.add(new StructElement(transitionTimeFieldID, transitionTimetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void getSceneMembership(GetSceneMembershipResponseCallback callback, Integer groupID) {
-      getSceneMembership(chipClusterPtr, callback, groupID, null);
+      getSceneMembership(callback, groupID, 0);
     }
 
     public void getSceneMembership(GetSceneMembershipResponseCallback callback, Integer groupID, int timedInvokeTimeoutMs) {
-      getSceneMembership(chipClusterPtr, callback, groupID, timedInvokeTimeoutMs);
+      final long commandId = 6L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long groupIDFieldID = 0L;
+      BaseTLVType groupIDtlvValue = new UIntType(groupID);
+      elements.add(new StructElement(groupIDFieldID, groupIDtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long capacityFieldID = 1L;
+          @Nullable Integer capacity = null;
+          final long groupIDFieldID = 2L;
+          Integer groupID = null;
+          final long sceneListFieldID = 3L;
+          Optional<ArrayList<Integer>> sceneList = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == capacityFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                capacity = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == groupIDFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                groupID = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == sceneListFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+                ArrayType castingValue = element.value(ArrayType.class);
+                sceneList = Optional.of(castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class)));
+              }
+            }
+          }
+          callback.onSuccess(status, capacity, groupID, sceneList);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void enhancedAddScene(EnhancedAddSceneResponseCallback callback, Integer groupID, Integer sceneID, Integer transitionTime, String sceneName, ArrayList<ChipStructs.ScenesClusterExtensionFieldSet> extensionFieldSets) {
-      enhancedAddScene(chipClusterPtr, callback, groupID, sceneID, transitionTime, sceneName, extensionFieldSets, null);
+      enhancedAddScene(callback, groupID, sceneID, transitionTime, sceneName, extensionFieldSets, 0);
     }
 
     public void enhancedAddScene(EnhancedAddSceneResponseCallback callback, Integer groupID, Integer sceneID, Integer transitionTime, String sceneName, ArrayList<ChipStructs.ScenesClusterExtensionFieldSet> extensionFieldSets, int timedInvokeTimeoutMs) {
-      enhancedAddScene(chipClusterPtr, callback, groupID, sceneID, transitionTime, sceneName, extensionFieldSets, timedInvokeTimeoutMs);
+      final long commandId = 64L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long groupIDFieldID = 0L;
+      BaseTLVType groupIDtlvValue = new UIntType(groupID);
+      elements.add(new StructElement(groupIDFieldID, groupIDtlvValue));
+
+      final long sceneIDFieldID = 1L;
+      BaseTLVType sceneIDtlvValue = new UIntType(sceneID);
+      elements.add(new StructElement(sceneIDFieldID, sceneIDtlvValue));
+
+      final long transitionTimeFieldID = 2L;
+      BaseTLVType transitionTimetlvValue = new UIntType(transitionTime);
+      elements.add(new StructElement(transitionTimeFieldID, transitionTimetlvValue));
+
+      final long sceneNameFieldID = 3L;
+      BaseTLVType sceneNametlvValue = new StringType(sceneName);
+      elements.add(new StructElement(sceneNameFieldID, sceneNametlvValue));
+
+      final long extensionFieldSetsFieldID = 4L;
+      BaseTLVType extensionFieldSetstlvValue = ArrayType.generateArrayType(extensionFieldSets, (elementextensionFieldSets) -> elementextensionFieldSets.encodeTlv());
+      elements.add(new StructElement(extensionFieldSetsFieldID, extensionFieldSetstlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long groupIDFieldID = 1L;
+          Integer groupID = null;
+          final long sceneIDFieldID = 2L;
+          Integer sceneID = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == groupIDFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                groupID = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == sceneIDFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                sceneID = castingValue.value(Integer.class);
+              }
+            }
+          }
+          callback.onSuccess(status, groupID, sceneID);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void enhancedViewScene(EnhancedViewSceneResponseCallback callback, Integer groupID, Integer sceneID) {
-      enhancedViewScene(chipClusterPtr, callback, groupID, sceneID, null);
+      enhancedViewScene(callback, groupID, sceneID, 0);
     }
 
     public void enhancedViewScene(EnhancedViewSceneResponseCallback callback, Integer groupID, Integer sceneID, int timedInvokeTimeoutMs) {
-      enhancedViewScene(chipClusterPtr, callback, groupID, sceneID, timedInvokeTimeoutMs);
+      final long commandId = 65L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long groupIDFieldID = 0L;
+      BaseTLVType groupIDtlvValue = new UIntType(groupID);
+      elements.add(new StructElement(groupIDFieldID, groupIDtlvValue));
+
+      final long sceneIDFieldID = 1L;
+      BaseTLVType sceneIDtlvValue = new UIntType(sceneID);
+      elements.add(new StructElement(sceneIDFieldID, sceneIDtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long groupIDFieldID = 1L;
+          Integer groupID = null;
+          final long sceneIDFieldID = 2L;
+          Integer sceneID = null;
+          final long transitionTimeFieldID = 3L;
+          Optional<Integer> transitionTime = Optional.empty();
+          final long sceneNameFieldID = 4L;
+          Optional<String> sceneName = Optional.empty();
+          final long extensionFieldSetsFieldID = 5L;
+          Optional<ArrayList<ChipStructs.ScenesClusterExtensionFieldSet>> extensionFieldSets = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == groupIDFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                groupID = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == sceneIDFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                sceneID = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == transitionTimeFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                transitionTime = Optional.of(castingValue.value(Integer.class));
+              }
+            } else if (element.contextTagNum() == sceneNameFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                sceneName = Optional.of(castingValue.value(String.class));
+              }
+            } else if (element.contextTagNum() == extensionFieldSetsFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+                ArrayType castingValue = element.value(ArrayType.class);
+                extensionFieldSets = Optional.of(castingValue.map((elementcastingValue) -> ChipStructs.ScenesClusterExtensionFieldSet.decodeTlv(elementcastingValue)));
+              }
+            }
+          }
+          callback.onSuccess(status, groupID, sceneID, transitionTime, sceneName, extensionFieldSets);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void copyScene(CopySceneResponseCallback callback, Integer mode, Integer groupIdentifierFrom, Integer sceneIdentifierFrom, Integer groupIdentifierTo, Integer sceneIdentifierTo) {
-      copyScene(chipClusterPtr, callback, mode, groupIdentifierFrom, sceneIdentifierFrom, groupIdentifierTo, sceneIdentifierTo, null);
+      copyScene(callback, mode, groupIdentifierFrom, sceneIdentifierFrom, groupIdentifierTo, sceneIdentifierTo, 0);
     }
 
     public void copyScene(CopySceneResponseCallback callback, Integer mode, Integer groupIdentifierFrom, Integer sceneIdentifierFrom, Integer groupIdentifierTo, Integer sceneIdentifierTo, int timedInvokeTimeoutMs) {
-      copyScene(chipClusterPtr, callback, mode, groupIdentifierFrom, sceneIdentifierFrom, groupIdentifierTo, sceneIdentifierTo, timedInvokeTimeoutMs);
-    }
-
-    private native void addScene(long chipClusterPtr, AddSceneResponseCallback callback, Integer groupID, Integer sceneID, Integer transitionTime, String sceneName, ArrayList<ChipStructs.ScenesClusterExtensionFieldSet> extensionFieldSets, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void viewScene(long chipClusterPtr, ViewSceneResponseCallback callback, Integer groupID, Integer sceneID, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void removeScene(long chipClusterPtr, RemoveSceneResponseCallback callback, Integer groupID, Integer sceneID, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void removeAllScenes(long chipClusterPtr, RemoveAllScenesResponseCallback callback, Integer groupID, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void storeScene(long chipClusterPtr, StoreSceneResponseCallback callback, Integer groupID, Integer sceneID, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void recallScene(long chipClusterPtr, DefaultClusterCallback callback, Integer groupID, Integer sceneID, @Nullable Optional<Integer> transitionTime, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void getSceneMembership(long chipClusterPtr, GetSceneMembershipResponseCallback callback, Integer groupID, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void enhancedAddScene(long chipClusterPtr, EnhancedAddSceneResponseCallback callback, Integer groupID, Integer sceneID, Integer transitionTime, String sceneName, ArrayList<ChipStructs.ScenesClusterExtensionFieldSet> extensionFieldSets, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void enhancedViewScene(long chipClusterPtr, EnhancedViewSceneResponseCallback callback, Integer groupID, Integer sceneID, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void copyScene(long chipClusterPtr, CopySceneResponseCallback callback, Integer mode, Integer groupIdentifierFrom, Integer sceneIdentifierFrom, Integer groupIdentifierTo, Integer sceneIdentifierTo, @Nullable Integer timedInvokeTimeoutMs);
-
-    public interface AddSceneResponseCallback {
+      final long commandId = 66L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long modeFieldID = 0L;
+      BaseTLVType modetlvValue = new UIntType(mode);
+      elements.add(new StructElement(modeFieldID, modetlvValue));
+
+      final long groupIdentifierFromFieldID = 1L;
+      BaseTLVType groupIdentifierFromtlvValue = new UIntType(groupIdentifierFrom);
+      elements.add(new StructElement(groupIdentifierFromFieldID, groupIdentifierFromtlvValue));
+
+      final long sceneIdentifierFromFieldID = 2L;
+      BaseTLVType sceneIdentifierFromtlvValue = new UIntType(sceneIdentifierFrom);
+      elements.add(new StructElement(sceneIdentifierFromFieldID, sceneIdentifierFromtlvValue));
+
+      final long groupIdentifierToFieldID = 3L;
+      BaseTLVType groupIdentifierTotlvValue = new UIntType(groupIdentifierTo);
+      elements.add(new StructElement(groupIdentifierToFieldID, groupIdentifierTotlvValue));
+
+      final long sceneIdentifierToFieldID = 4L;
+      BaseTLVType sceneIdentifierTotlvValue = new UIntType(sceneIdentifierTo);
+      elements.add(new StructElement(sceneIdentifierToFieldID, sceneIdentifierTotlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long groupIdentifierFromFieldID = 1L;
+          Integer groupIdentifierFrom = null;
+          final long sceneIdentifierFromFieldID = 2L;
+          Integer sceneIdentifierFrom = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == groupIdentifierFromFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                groupIdentifierFrom = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == sceneIdentifierFromFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                sceneIdentifierFrom = castingValue.value(Integer.class);
+              }
+            }
+          }
+          callback.onSuccess(status, groupIdentifierFrom, sceneIdentifierFrom);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface AddSceneResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, Integer groupID, Integer sceneID);
-      void onError(Exception error);
     }
 
-    public interface ViewSceneResponseCallback {
+    public interface ViewSceneResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, Integer groupID, Integer sceneID, Optional<Integer> transitionTime, Optional<String> sceneName, Optional<ArrayList<ChipStructs.ScenesClusterExtensionFieldSet>> extensionFieldSets);
-      void onError(Exception error);
     }
 
-    public interface RemoveSceneResponseCallback {
+    public interface RemoveSceneResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, Integer groupID, Integer sceneID);
-      void onError(Exception error);
     }
 
-    public interface RemoveAllScenesResponseCallback {
+    public interface RemoveAllScenesResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, Integer groupID);
-      void onError(Exception error);
     }
 
-    public interface StoreSceneResponseCallback {
+    public interface StoreSceneResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, Integer groupID, Integer sceneID);
-      void onError(Exception error);
     }
 
-    public interface GetSceneMembershipResponseCallback {
+    public interface GetSceneMembershipResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, @Nullable Integer capacity, Integer groupID, Optional<ArrayList<Integer>> sceneList);
-      void onError(Exception error);
     }
 
-    public interface EnhancedAddSceneResponseCallback {
+    public interface EnhancedAddSceneResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, Integer groupID, Integer sceneID);
-      void onError(Exception error);
     }
 
-    public interface EnhancedViewSceneResponseCallback {
+    public interface EnhancedViewSceneResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, Integer groupID, Integer sceneID, Optional<Integer> transitionTime, Optional<String> sceneName, Optional<ArrayList<ChipStructs.ScenesClusterExtensionFieldSet>> extensionFieldSets);
-      void onError(Exception error);
     }
 
-    public interface CopySceneResponseCallback {
+    public interface CopySceneResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, Integer groupIdentifierFrom, Integer sceneIdentifierFrom);
-      void onError(Exception error);
     }
 
-    public interface LastConfiguredByAttributeCallback {
+    public interface LastConfiguredByAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readSceneCountAttribute(
         IntegerAttributeCallback callback) {
-        readSceneCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SCENE_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SCENE_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSceneCountAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSceneCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SCENE_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SCENE_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentSceneAttribute(
         IntegerAttributeCallback callback) {
-        readCurrentSceneAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_SCENE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_SCENE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentSceneAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentSceneAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_SCENE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_SCENE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentGroupAttribute(
         IntegerAttributeCallback callback) {
-        readCurrentGroupAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_GROUP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_GROUP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentGroupAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentGroupAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_GROUP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_GROUP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSceneValidAttribute(
         BooleanAttributeCallback callback) {
-        readSceneValidAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SCENE_VALID_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SCENE_VALID_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSceneValidAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSceneValidAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SCENE_VALID_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SCENE_VALID_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readNameSupportAttribute(
         IntegerAttributeCallback callback) {
-        readNameSupportAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NAME_SUPPORT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NAME_SUPPORT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeNameSupportAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNameSupportAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NAME_SUPPORT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NAME_SUPPORT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLastConfiguredByAttribute(
         LastConfiguredByAttributeCallback callback) {
-        readLastConfiguredByAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAST_CONFIGURED_BY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LAST_CONFIGURED_BY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLastConfiguredByAttribute(
         LastConfiguredByAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLastConfiguredByAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAST_CONFIGURED_BY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LAST_CONFIGURED_BY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSceneTableSizeAttribute(
         IntegerAttributeCallback callback) {
-        readSceneTableSizeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SCENE_TABLE_SIZE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SCENE_TABLE_SIZE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSceneTableSizeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSceneTableSizeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SCENE_TABLE_SIZE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SCENE_TABLE_SIZE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRemainingCapacityAttribute(
         IntegerAttributeCallback callback) {
-        readRemainingCapacityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REMAINING_CAPACITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, REMAINING_CAPACITY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRemainingCapacityAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRemainingCapacityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REMAINING_CAPACITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, REMAINING_CAPACITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readLastConfiguredByAttribute(long chipClusterPtr, LastConfiguredByAttributeCallback callback);
-
-    private native void subscribeLastConfiguredByAttribute(long chipClusterPtr, LastConfiguredByAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSceneTableSizeAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeSceneTableSizeAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRemainingCapacityAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRemainingCapacityAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class OnOffCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 6L;
 
+    private static final long ON_OFF_ATTRIBUTE_ID = 0L;
+    private static final long GLOBAL_SCENE_CONTROL_ATTRIBUTE_ID = 16384L;
+    private static final long ON_TIME_ATTRIBUTE_ID = 16385L;
+    private static final long OFF_WAIT_TIME_ATTRIBUTE_ID = 16386L;
+    private static final long START_UP_ON_OFF_ATTRIBUTE_ID = 16387L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public OnOffCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void off(DefaultClusterCallback callback) {
-      off(chipClusterPtr, callback, null);
+      off(callback, 0);
     }
 
     public void off(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      off(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void on(DefaultClusterCallback callback) {
-      on(chipClusterPtr, callback, null);
+      on(callback, 0);
     }
 
     public void on(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      on(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 1L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void toggle(DefaultClusterCallback callback) {
-      toggle(chipClusterPtr, callback, null);
+      toggle(callback, 0);
     }
 
     public void toggle(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      toggle(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 2L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void offWithEffect(DefaultClusterCallback callback, Integer effectIdentifier, Integer effectVariant) {
-      offWithEffect(chipClusterPtr, callback, effectIdentifier, effectVariant, null);
+      offWithEffect(callback, effectIdentifier, effectVariant, 0);
     }
 
     public void offWithEffect(DefaultClusterCallback callback, Integer effectIdentifier, Integer effectVariant, int timedInvokeTimeoutMs) {
-      offWithEffect(chipClusterPtr, callback, effectIdentifier, effectVariant, timedInvokeTimeoutMs);
+      final long commandId = 64L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long effectIdentifierFieldID = 0L;
+      BaseTLVType effectIdentifiertlvValue = new UIntType(effectIdentifier);
+      elements.add(new StructElement(effectIdentifierFieldID, effectIdentifiertlvValue));
+
+      final long effectVariantFieldID = 1L;
+      BaseTLVType effectVarianttlvValue = new UIntType(effectVariant);
+      elements.add(new StructElement(effectVariantFieldID, effectVarianttlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void onWithRecallGlobalScene(DefaultClusterCallback callback) {
-      onWithRecallGlobalScene(chipClusterPtr, callback, null);
+      onWithRecallGlobalScene(callback, 0);
     }
 
     public void onWithRecallGlobalScene(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      onWithRecallGlobalScene(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 65L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void onWithTimedOff(DefaultClusterCallback callback, Integer onOffControl, Integer onTime, Integer offWaitTime) {
-      onWithTimedOff(chipClusterPtr, callback, onOffControl, onTime, offWaitTime, null);
+      onWithTimedOff(callback, onOffControl, onTime, offWaitTime, 0);
     }
 
     public void onWithTimedOff(DefaultClusterCallback callback, Integer onOffControl, Integer onTime, Integer offWaitTime, int timedInvokeTimeoutMs) {
-      onWithTimedOff(chipClusterPtr, callback, onOffControl, onTime, offWaitTime, timedInvokeTimeoutMs);
-    }
-
-    private native void off(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
+      final long commandId = 66L;
 
-    private native void on(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long onOffControlFieldID = 0L;
+      BaseTLVType onOffControltlvValue = new UIntType(onOffControl);
+      elements.add(new StructElement(onOffControlFieldID, onOffControltlvValue));
 
-    private native void toggle(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
+      final long onTimeFieldID = 1L;
+      BaseTLVType onTimetlvValue = new UIntType(onTime);
+      elements.add(new StructElement(onTimeFieldID, onTimetlvValue));
 
-    private native void offWithEffect(long chipClusterPtr, DefaultClusterCallback callback, Integer effectIdentifier, Integer effectVariant, @Nullable Integer timedInvokeTimeoutMs);
+      final long offWaitTimeFieldID = 2L;
+      BaseTLVType offWaitTimetlvValue = new UIntType(offWaitTime);
+      elements.add(new StructElement(offWaitTimeFieldID, offWaitTimetlvValue));
 
-    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);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface StartUpOnOffAttributeCallback {
+    public interface StartUpOnOffAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readOnOffAttribute(
         BooleanAttributeCallback callback) {
-        readOnOffAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_OFF_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ON_OFF_ATTRIBUTE_ID, true);
     }
 
     public void subscribeOnOffAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOnOffAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_OFF_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ON_OFF_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGlobalSceneControlAttribute(
         BooleanAttributeCallback callback) {
-        readGlobalSceneControlAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GLOBAL_SCENE_CONTROL_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GLOBAL_SCENE_CONTROL_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGlobalSceneControlAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGlobalSceneControlAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GLOBAL_SCENE_CONTROL_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GLOBAL_SCENE_CONTROL_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOnTimeAttribute(
         IntegerAttributeCallback callback) {
-        readOnTimeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_TIME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ON_TIME_ATTRIBUTE_ID, true);
     }
 
     public void writeOnTimeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOnTimeAttribute(chipClusterPtr, callback, value, null);
+      writeOnTimeAttribute(callback, value, 0);
     }
 
     public void writeOnTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOnTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ON_TIME_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOnTimeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOnTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_TIME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ON_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOffWaitTimeAttribute(
         IntegerAttributeCallback callback) {
-        readOffWaitTimeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OFF_WAIT_TIME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OFF_WAIT_TIME_ATTRIBUTE_ID, true);
     }
 
     public void writeOffWaitTimeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOffWaitTimeAttribute(chipClusterPtr, callback, value, null);
+      writeOffWaitTimeAttribute(callback, value, 0);
     }
 
     public void writeOffWaitTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOffWaitTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), OFF_WAIT_TIME_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOffWaitTimeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOffWaitTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OFF_WAIT_TIME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OFF_WAIT_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readStartUpOnOffAttribute(
         StartUpOnOffAttributeCallback callback) {
-        readStartUpOnOffAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, START_UP_ON_OFF_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, START_UP_ON_OFF_ATTRIBUTE_ID, true);
     }
 
     public void writeStartUpOnOffAttribute(DefaultClusterCallback callback, Integer value) {
-        writeStartUpOnOffAttribute(chipClusterPtr, callback, value, null);
+      writeStartUpOnOffAttribute(callback, value, 0);
     }
 
     public void writeStartUpOnOffAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeStartUpOnOffAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), START_UP_ON_OFF_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeStartUpOnOffAttribute(
         StartUpOnOffAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeStartUpOnOffAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, START_UP_ON_OFF_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, START_UP_ON_OFF_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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, StartUpOnOffAttributeCallback callback);
-
-    private native void writeStartUpOnOffAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeStartUpOnOffAttribute(long chipClusterPtr, StartUpOnOffAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class OnOffSwitchConfigurationCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 7L;
 
+    private static final long SWITCH_TYPE_ATTRIBUTE_ID = 0L;
+    private static final long SWITCH_ACTIONS_ATTRIBUTE_ID = 16L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public OnOffSwitchConfigurationCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readSwitchTypeAttribute(
         IntegerAttributeCallback callback) {
-        readSwitchTypeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SWITCH_TYPE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SWITCH_TYPE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSwitchTypeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSwitchTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SWITCH_TYPE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SWITCH_TYPE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSwitchActionsAttribute(
         IntegerAttributeCallback callback) {
-        readSwitchActionsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SWITCH_ACTIONS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SWITCH_ACTIONS_ATTRIBUTE_ID, true);
     }
 
     public void writeSwitchActionsAttribute(DefaultClusterCallback callback, Integer value) {
-        writeSwitchActionsAttribute(chipClusterPtr, callback, value, null);
+      writeSwitchActionsAttribute(callback, value, 0);
     }
 
     public void writeSwitchActionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeSwitchActionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), SWITCH_ACTIONS_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeSwitchActionsAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSwitchActionsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SWITCH_ACTIONS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SWITCH_ACTIONS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
+  }
 
-    private native void readSwitchTypeAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+  public static class LevelControlCluster extends BaseChipCluster {
+    public static final long CLUSTER_ID = 8L;
 
-    private native void subscribeSwitchTypeAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    private static final long CURRENT_LEVEL_ATTRIBUTE_ID = 0L;
+    private static final long REMAINING_TIME_ATTRIBUTE_ID = 1L;
+    private static final long MIN_LEVEL_ATTRIBUTE_ID = 2L;
+    private static final long MAX_LEVEL_ATTRIBUTE_ID = 3L;
+    private static final long CURRENT_FREQUENCY_ATTRIBUTE_ID = 4L;
+    private static final long MIN_FREQUENCY_ATTRIBUTE_ID = 5L;
+    private static final long MAX_FREQUENCY_ATTRIBUTE_ID = 6L;
+    private static final long OPTIONS_ATTRIBUTE_ID = 15L;
+    private static final long ON_OFF_TRANSITION_TIME_ATTRIBUTE_ID = 16L;
+    private static final long ON_LEVEL_ATTRIBUTE_ID = 17L;
+    private static final long ON_TRANSITION_TIME_ATTRIBUTE_ID = 18L;
+    private static final long OFF_TRANSITION_TIME_ATTRIBUTE_ID = 19L;
+    private static final long DEFAULT_MOVE_RATE_ATTRIBUTE_ID = 20L;
+    private static final long START_UP_CURRENT_LEVEL_ATTRIBUTE_ID = 16384L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
 
-    private native void readSwitchActionsAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public LevelControlCluster(long devicePtr, int endpointId) {
+      super(devicePtr, endpointId, CLUSTER_ID);
+    }
 
-    private native void writeSwitchActionsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    @Override
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    private native void subscribeSwitchActionsAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void moveToLevel(DefaultClusterCallback callback, Integer level, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride) {
+      moveToLevel(callback, level, transitionTime, optionsMask, optionsOverride, 0);
+    }
 
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
+    public void moveToLevel(DefaultClusterCallback callback, Integer level, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
+      final long commandId = 0L;
 
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long levelFieldID = 0L;
+      BaseTLVType leveltlvValue = new UIntType(level);
+      elements.add(new StructElement(levelFieldID, leveltlvValue));
 
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
+      final long transitionTimeFieldID = 1L;
+      BaseTLVType transitionTimetlvValue = transitionTime != null ? new UIntType(transitionTime) : new NullType();
+      elements.add(new StructElement(transitionTimeFieldID, transitionTimetlvValue));
 
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      final long optionsMaskFieldID = 2L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
 
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
+      final long optionsOverrideFieldID = 3L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
 
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
+    public void move(DefaultClusterCallback callback, Integer moveMode, @Nullable Integer rate, Integer optionsMask, Integer optionsOverride) {
+      move(callback, moveMode, rate, optionsMask, optionsOverride, 0);
+    }
 
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
+    public void move(DefaultClusterCallback callback, Integer moveMode, @Nullable Integer rate, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
+      final long commandId = 1L;
 
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long moveModeFieldID = 0L;
+      BaseTLVType moveModetlvValue = new UIntType(moveMode);
+      elements.add(new StructElement(moveModeFieldID, moveModetlvValue));
 
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+      final long rateFieldID = 1L;
+      BaseTLVType ratetlvValue = rate != null ? new UIntType(rate) : new NullType();
+      elements.add(new StructElement(rateFieldID, ratetlvValue));
 
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+      final long optionsMaskFieldID = 2L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
 
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-  }
+      final long optionsOverrideFieldID = 3L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
 
-  public static class LevelControlCluster extends BaseChipCluster {
-    public static final long CLUSTER_ID = 8L;
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public LevelControlCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+    public void step(DefaultClusterCallback callback, Integer stepMode, Integer stepSize, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride) {
+      step(callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, 0);
     }
 
-    @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    public void step(DefaultClusterCallback callback, Integer stepMode, Integer stepSize, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
+      final long commandId = 2L;
 
-    public void moveToLevel(DefaultClusterCallback callback, Integer level, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride) {
-      moveToLevel(chipClusterPtr, callback, level, transitionTime, optionsMask, optionsOverride, null);
-    }
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long stepModeFieldID = 0L;
+      BaseTLVType stepModetlvValue = new UIntType(stepMode);
+      elements.add(new StructElement(stepModeFieldID, stepModetlvValue));
 
-    public void moveToLevel(DefaultClusterCallback callback, Integer level, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
-      moveToLevel(chipClusterPtr, callback, level, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs);
-    }
+      final long stepSizeFieldID = 1L;
+      BaseTLVType stepSizetlvValue = new UIntType(stepSize);
+      elements.add(new StructElement(stepSizeFieldID, stepSizetlvValue));
 
-    public void move(DefaultClusterCallback callback, Integer moveMode, @Nullable Integer rate, Integer optionsMask, Integer optionsOverride) {
-      move(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null);
-    }
+      final long transitionTimeFieldID = 2L;
+      BaseTLVType transitionTimetlvValue = transitionTime != null ? new UIntType(transitionTime) : new NullType();
+      elements.add(new StructElement(transitionTimeFieldID, transitionTimetlvValue));
 
-    public void move(DefaultClusterCallback callback, Integer moveMode, @Nullable Integer rate, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
-      move(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs);
-    }
+      final long optionsMaskFieldID = 3L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
 
-    public void step(DefaultClusterCallback callback, Integer stepMode, Integer stepSize, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride) {
-      step(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null);
-    }
+      final long optionsOverrideFieldID = 4L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
 
-    public void step(DefaultClusterCallback callback, Integer stepMode, Integer stepSize, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
-      step(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void stop(DefaultClusterCallback callback, Integer optionsMask, Integer optionsOverride) {
-      stop(chipClusterPtr, callback, optionsMask, optionsOverride, null);
+      stop(callback, optionsMask, optionsOverride, 0);
     }
 
     public void stop(DefaultClusterCallback callback, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
-      stop(chipClusterPtr, callback, optionsMask, optionsOverride, timedInvokeTimeoutMs);
+      final long commandId = 3L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long optionsMaskFieldID = 0L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
+
+      final long optionsOverrideFieldID = 1L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void moveToLevelWithOnOff(DefaultClusterCallback callback, Integer level, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride) {
-      moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, optionsMask, optionsOverride, null);
+      moveToLevelWithOnOff(callback, level, transitionTime, optionsMask, optionsOverride, 0);
     }
 
     public void moveToLevelWithOnOff(DefaultClusterCallback callback, Integer level, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
-      moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs);
+      final long commandId = 4L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long levelFieldID = 0L;
+      BaseTLVType leveltlvValue = new UIntType(level);
+      elements.add(new StructElement(levelFieldID, leveltlvValue));
+
+      final long transitionTimeFieldID = 1L;
+      BaseTLVType transitionTimetlvValue = transitionTime != null ? new UIntType(transitionTime) : new NullType();
+      elements.add(new StructElement(transitionTimeFieldID, transitionTimetlvValue));
+
+      final long optionsMaskFieldID = 2L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
+
+      final long optionsOverrideFieldID = 3L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void moveWithOnOff(DefaultClusterCallback callback, Integer moveMode, @Nullable Integer rate, Integer optionsMask, Integer optionsOverride) {
-      moveWithOnOff(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null);
+      moveWithOnOff(callback, moveMode, rate, optionsMask, optionsOverride, 0);
     }
 
     public void moveWithOnOff(DefaultClusterCallback callback, Integer moveMode, @Nullable Integer rate, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
-      moveWithOnOff(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs);
+      final long commandId = 5L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long moveModeFieldID = 0L;
+      BaseTLVType moveModetlvValue = new UIntType(moveMode);
+      elements.add(new StructElement(moveModeFieldID, moveModetlvValue));
+
+      final long rateFieldID = 1L;
+      BaseTLVType ratetlvValue = rate != null ? new UIntType(rate) : new NullType();
+      elements.add(new StructElement(rateFieldID, ratetlvValue));
+
+      final long optionsMaskFieldID = 2L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
+
+      final long optionsOverrideFieldID = 3L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void stepWithOnOff(DefaultClusterCallback callback, Integer stepMode, Integer stepSize, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride) {
-      stepWithOnOff(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null);
+      stepWithOnOff(callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, 0);
     }
 
     public void stepWithOnOff(DefaultClusterCallback callback, Integer stepMode, Integer stepSize, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
-      stepWithOnOff(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs);
-    }
+      final long commandId = 6L;
 
-    public void stopWithOnOff(DefaultClusterCallback callback, Integer optionsMask, Integer optionsOverride) {
-      stopWithOnOff(chipClusterPtr, callback, optionsMask, optionsOverride, null);
-    }
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long stepModeFieldID = 0L;
+      BaseTLVType stepModetlvValue = new UIntType(stepMode);
+      elements.add(new StructElement(stepModeFieldID, stepModetlvValue));
 
-    public void stopWithOnOff(DefaultClusterCallback callback, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
-      stopWithOnOff(chipClusterPtr, callback, optionsMask, optionsOverride, timedInvokeTimeoutMs);
-    }
+      final long stepSizeFieldID = 1L;
+      BaseTLVType stepSizetlvValue = new UIntType(stepSize);
+      elements.add(new StructElement(stepSizeFieldID, stepSizetlvValue));
 
-    public void moveToClosestFrequency(DefaultClusterCallback callback, Integer frequency) {
-      moveToClosestFrequency(chipClusterPtr, callback, frequency, null);
-    }
+      final long transitionTimeFieldID = 2L;
+      BaseTLVType transitionTimetlvValue = transitionTime != null ? new UIntType(transitionTime) : new NullType();
+      elements.add(new StructElement(transitionTimeFieldID, transitionTimetlvValue));
 
-    public void moveToClosestFrequency(DefaultClusterCallback callback, Integer frequency, int timedInvokeTimeoutMs) {
-      moveToClosestFrequency(chipClusterPtr, callback, frequency, timedInvokeTimeoutMs);
+      final long optionsMaskFieldID = 3L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
+
+      final long optionsOverrideFieldID = 4L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
-    private native void moveToLevel(long chipClusterPtr, DefaultClusterCallback callback, Integer level, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+    public void stopWithOnOff(DefaultClusterCallback callback, Integer optionsMask, Integer optionsOverride) {
+      stopWithOnOff(callback, optionsMask, optionsOverride, 0);
+    }
 
-    private native void move(long chipClusterPtr, DefaultClusterCallback callback, Integer moveMode, @Nullable Integer rate, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+    public void stopWithOnOff(DefaultClusterCallback callback, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
+      final long commandId = 7L;
 
-    private native void step(long chipClusterPtr, DefaultClusterCallback callback, Integer stepMode, Integer stepSize, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long optionsMaskFieldID = 0L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
 
-    private native void stop(long chipClusterPtr, DefaultClusterCallback callback, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+      final long optionsOverrideFieldID = 1L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
 
-    private native void moveToLevelWithOnOff(long chipClusterPtr, DefaultClusterCallback callback, Integer level, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void moveWithOnOff(long chipClusterPtr, DefaultClusterCallback callback, Integer moveMode, @Nullable Integer rate, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+    public void moveToClosestFrequency(DefaultClusterCallback callback, Integer frequency) {
+      moveToClosestFrequency(callback, frequency, 0);
+    }
 
-    private native void stepWithOnOff(long chipClusterPtr, DefaultClusterCallback callback, Integer stepMode, Integer stepSize, @Nullable Integer transitionTime, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+    public void moveToClosestFrequency(DefaultClusterCallback callback, Integer frequency, int timedInvokeTimeoutMs) {
+      final long commandId = 8L;
 
-    private native void stopWithOnOff(long chipClusterPtr, DefaultClusterCallback callback, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long frequencyFieldID = 0L;
+      BaseTLVType frequencytlvValue = new UIntType(frequency);
+      elements.add(new StructElement(frequencyFieldID, frequencytlvValue));
 
-    private native void moveToClosestFrequency(long chipClusterPtr, DefaultClusterCallback callback, Integer frequency, @Nullable Integer timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface CurrentLevelAttributeCallback {
+    public interface CurrentLevelAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface OnLevelAttributeCallback {
+    public interface OnLevelAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface OnTransitionTimeAttributeCallback {
+    public interface OnTransitionTimeAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface OffTransitionTimeAttributeCallback {
+    public interface OffTransitionTimeAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface DefaultMoveRateAttributeCallback {
+    public interface DefaultMoveRateAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface StartUpCurrentLevelAttributeCallback {
+    public interface StartUpCurrentLevelAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readCurrentLevelAttribute(
         CurrentLevelAttributeCallback callback) {
-        readCurrentLevelAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_LEVEL_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_LEVEL_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentLevelAttribute(
         CurrentLevelAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_LEVEL_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_LEVEL_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRemainingTimeAttribute(
         IntegerAttributeCallback callback) {
-        readRemainingTimeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REMAINING_TIME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, REMAINING_TIME_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRemainingTimeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRemainingTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REMAINING_TIME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, REMAINING_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinLevelAttribute(
         IntegerAttributeCallback callback) {
-        readMinLevelAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_LEVEL_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_LEVEL_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinLevelAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_LEVEL_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_LEVEL_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxLevelAttribute(
         IntegerAttributeCallback callback) {
-        readMaxLevelAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_LEVEL_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_LEVEL_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxLevelAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_LEVEL_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_LEVEL_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentFrequencyAttribute(
         IntegerAttributeCallback callback) {
-        readCurrentFrequencyAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_FREQUENCY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_FREQUENCY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentFrequencyAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_FREQUENCY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_FREQUENCY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinFrequencyAttribute(
         IntegerAttributeCallback callback) {
-        readMinFrequencyAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_FREQUENCY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_FREQUENCY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinFrequencyAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_FREQUENCY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_FREQUENCY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxFrequencyAttribute(
         IntegerAttributeCallback callback) {
-        readMaxFrequencyAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_FREQUENCY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_FREQUENCY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxFrequencyAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_FREQUENCY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_FREQUENCY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOptionsAttribute(
         IntegerAttributeCallback callback) {
-        readOptionsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPTIONS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OPTIONS_ATTRIBUTE_ID, true);
     }
 
     public void writeOptionsAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOptionsAttribute(chipClusterPtr, callback, value, null);
+      writeOptionsAttribute(callback, value, 0);
     }
 
     public void writeOptionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOptionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), OPTIONS_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOptionsAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOptionsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPTIONS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OPTIONS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOnOffTransitionTimeAttribute(
         IntegerAttributeCallback callback) {
-        readOnOffTransitionTimeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_OFF_TRANSITION_TIME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ON_OFF_TRANSITION_TIME_ATTRIBUTE_ID, true);
     }
 
     public void writeOnOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOnOffTransitionTimeAttribute(chipClusterPtr, callback, value, null);
+      writeOnOffTransitionTimeAttribute(callback, value, 0);
     }
 
     public void writeOnOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOnOffTransitionTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ON_OFF_TRANSITION_TIME_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOnOffTransitionTimeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOnOffTransitionTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_OFF_TRANSITION_TIME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ON_OFF_TRANSITION_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOnLevelAttribute(
         OnLevelAttributeCallback callback) {
-        readOnLevelAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_LEVEL_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ON_LEVEL_ATTRIBUTE_ID, true);
     }
 
     public void writeOnLevelAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOnLevelAttribute(chipClusterPtr, callback, value, null);
+      writeOnLevelAttribute(callback, value, 0);
     }
 
     public void writeOnLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOnLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ON_LEVEL_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOnLevelAttribute(
         OnLevelAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOnLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_LEVEL_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ON_LEVEL_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOnTransitionTimeAttribute(
         OnTransitionTimeAttributeCallback callback) {
-        readOnTransitionTimeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_TRANSITION_TIME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ON_TRANSITION_TIME_ATTRIBUTE_ID, true);
     }
 
     public void writeOnTransitionTimeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOnTransitionTimeAttribute(chipClusterPtr, callback, value, null);
+      writeOnTransitionTimeAttribute(callback, value, 0);
     }
 
     public void writeOnTransitionTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOnTransitionTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ON_TRANSITION_TIME_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOnTransitionTimeAttribute(
         OnTransitionTimeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOnTransitionTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_TRANSITION_TIME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ON_TRANSITION_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOffTransitionTimeAttribute(
         OffTransitionTimeAttributeCallback callback) {
-        readOffTransitionTimeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OFF_TRANSITION_TIME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OFF_TRANSITION_TIME_ATTRIBUTE_ID, true);
     }
 
     public void writeOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOffTransitionTimeAttribute(chipClusterPtr, callback, value, null);
+      writeOffTransitionTimeAttribute(callback, value, 0);
     }
 
     public void writeOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOffTransitionTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), OFF_TRANSITION_TIME_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOffTransitionTimeAttribute(
         OffTransitionTimeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOffTransitionTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OFF_TRANSITION_TIME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OFF_TRANSITION_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDefaultMoveRateAttribute(
         DefaultMoveRateAttributeCallback callback) {
-        readDefaultMoveRateAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DEFAULT_MOVE_RATE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DEFAULT_MOVE_RATE_ATTRIBUTE_ID, true);
     }
 
     public void writeDefaultMoveRateAttribute(DefaultClusterCallback callback, Integer value) {
-        writeDefaultMoveRateAttribute(chipClusterPtr, callback, value, null);
+      writeDefaultMoveRateAttribute(callback, value, 0);
     }
 
     public void writeDefaultMoveRateAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeDefaultMoveRateAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), DEFAULT_MOVE_RATE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeDefaultMoveRateAttribute(
         DefaultMoveRateAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDefaultMoveRateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DEFAULT_MOVE_RATE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DEFAULT_MOVE_RATE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readStartUpCurrentLevelAttribute(
         StartUpCurrentLevelAttributeCallback callback) {
-        readStartUpCurrentLevelAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, START_UP_CURRENT_LEVEL_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, START_UP_CURRENT_LEVEL_ATTRIBUTE_ID, true);
     }
 
     public void writeStartUpCurrentLevelAttribute(DefaultClusterCallback callback, Integer value) {
-        writeStartUpCurrentLevelAttribute(chipClusterPtr, callback, value, null);
+      writeStartUpCurrentLevelAttribute(callback, value, 0);
     }
 
     public void writeStartUpCurrentLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeStartUpCurrentLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), START_UP_CURRENT_LEVEL_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeStartUpCurrentLevelAttribute(
         StartUpCurrentLevelAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeStartUpCurrentLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, START_UP_CURRENT_LEVEL_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, START_UP_CURRENT_LEVEL_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readCurrentLevelAttribute(long chipClusterPtr, CurrentLevelAttributeCallback callback);
-
-    private native void subscribeCurrentLevelAttribute(long chipClusterPtr, CurrentLevelAttributeCallback 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 readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    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);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class BinaryInputBasicCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 15L;
 
+    private static final long ACTIVE_TEXT_ATTRIBUTE_ID = 4L;
+    private static final long DESCRIPTION_ATTRIBUTE_ID = 28L;
+    private static final long INACTIVE_TEXT_ATTRIBUTE_ID = 46L;
+    private static final long OUT_OF_SERVICE_ATTRIBUTE_ID = 81L;
+    private static final long POLARITY_ATTRIBUTE_ID = 84L;
+    private static final long PRESENT_VALUE_ATTRIBUTE_ID = 85L;
+    private static final long RELIABILITY_ATTRIBUTE_ID = 103L;
+    private static final long STATUS_FLAGS_ATTRIBUTE_ID = 111L;
+    private static final long APPLICATION_TYPE_ATTRIBUTE_ID = 256L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public BinaryInputBasicCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readActiveTextAttribute(
         CharStringAttributeCallback callback) {
-        readActiveTextAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_TEXT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_TEXT_ATTRIBUTE_ID, true);
     }
 
     public void writeActiveTextAttribute(DefaultClusterCallback callback, String value) {
-        writeActiveTextAttribute(chipClusterPtr, callback, value, null);
+      writeActiveTextAttribute(callback, value, 0);
     }
 
     public void writeActiveTextAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) {
-        writeActiveTextAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new StringType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ACTIVE_TEXT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeActiveTextAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActiveTextAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_TEXT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_TEXT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDescriptionAttribute(
         CharStringAttributeCallback callback) {
-        readDescriptionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DESCRIPTION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DESCRIPTION_ATTRIBUTE_ID, true);
     }
 
     public void writeDescriptionAttribute(DefaultClusterCallback callback, String value) {
-        writeDescriptionAttribute(chipClusterPtr, callback, value, null);
+      writeDescriptionAttribute(callback, value, 0);
     }
 
     public void writeDescriptionAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) {
-        writeDescriptionAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new StringType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), DESCRIPTION_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeDescriptionAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDescriptionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DESCRIPTION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DESCRIPTION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readInactiveTextAttribute(
         CharStringAttributeCallback callback) {
-        readInactiveTextAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INACTIVE_TEXT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INACTIVE_TEXT_ATTRIBUTE_ID, true);
     }
 
     public void writeInactiveTextAttribute(DefaultClusterCallback callback, String value) {
-        writeInactiveTextAttribute(chipClusterPtr, callback, value, null);
+      writeInactiveTextAttribute(callback, value, 0);
     }
 
     public void writeInactiveTextAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) {
-        writeInactiveTextAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new StringType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), INACTIVE_TEXT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeInactiveTextAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInactiveTextAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INACTIVE_TEXT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INACTIVE_TEXT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOutOfServiceAttribute(
         BooleanAttributeCallback callback) {
-        readOutOfServiceAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OUT_OF_SERVICE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OUT_OF_SERVICE_ATTRIBUTE_ID, true);
     }
 
     public void writeOutOfServiceAttribute(DefaultClusterCallback callback, Boolean value) {
-        writeOutOfServiceAttribute(chipClusterPtr, callback, value, null);
+      writeOutOfServiceAttribute(callback, value, 0);
     }
 
     public void writeOutOfServiceAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
-        writeOutOfServiceAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new BooleanType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), OUT_OF_SERVICE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOutOfServiceAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOutOfServiceAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OUT_OF_SERVICE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OUT_OF_SERVICE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPolarityAttribute(
         IntegerAttributeCallback callback) {
-        readPolarityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, POLARITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, POLARITY_ATTRIBUTE_ID, true);
     }
 
     public void subscribePolarityAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePolarityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, POLARITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, POLARITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPresentValueAttribute(
         BooleanAttributeCallback callback) {
-        readPresentValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRESENT_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRESENT_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void writePresentValueAttribute(DefaultClusterCallback callback, Boolean value) {
-        writePresentValueAttribute(chipClusterPtr, callback, value, null);
+      writePresentValueAttribute(callback, value, 0);
     }
 
     public void writePresentValueAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
-        writePresentValueAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new BooleanType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), PRESENT_VALUE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribePresentValueAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePresentValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRESENT_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRESENT_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readReliabilityAttribute(
         IntegerAttributeCallback callback) {
-        readReliabilityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RELIABILITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RELIABILITY_ATTRIBUTE_ID, true);
     }
 
     public void writeReliabilityAttribute(DefaultClusterCallback callback, Integer value) {
-        writeReliabilityAttribute(chipClusterPtr, callback, value, null);
+      writeReliabilityAttribute(callback, value, 0);
     }
 
     public void writeReliabilityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeReliabilityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), RELIABILITY_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeReliabilityAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeReliabilityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RELIABILITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RELIABILITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readStatusFlagsAttribute(
         IntegerAttributeCallback callback) {
-        readStatusFlagsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STATUS_FLAGS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, STATUS_FLAGS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeStatusFlagsAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeStatusFlagsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STATUS_FLAGS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, STATUS_FLAGS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readApplicationTypeAttribute(
         LongAttributeCallback callback) {
-        readApplicationTypeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, APPLICATION_TYPE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, APPLICATION_TYPE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeApplicationTypeAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeApplicationTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, APPLICATION_TYPE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, APPLICATION_TYPE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
+  }
 
-    private native void readActiveTextAttribute(long chipClusterPtr, CharStringAttributeCallback callback);
+  public static class PulseWidthModulationCluster extends BaseChipCluster {
+    public static final long CLUSTER_ID = 28L;
 
-    private native void writeActiveTextAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs);
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
 
-    private native void subscribeActiveTextAttribute(long chipClusterPtr, CharStringAttributeCallback callback, int minInterval, int maxInterval);
+    public PulseWidthModulationCluster(long devicePtr, int endpointId) {
+      super(devicePtr, endpointId, CLUSTER_ID);
+    }
 
-    private native void readDescriptionAttribute(long chipClusterPtr, CharStringAttributeCallback callback);
+    @Override
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    private native void writeDescriptionAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs);
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void subscribeDescriptionAttribute(long chipClusterPtr, CharStringAttributeCallback callback, int minInterval, int maxInterval);
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void readInactiveTextAttribute(long chipClusterPtr, CharStringAttributeCallback callback);
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void writeInactiveTextAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs);
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void subscribeInactiveTextAttribute(long chipClusterPtr, CharStringAttributeCallback callback, int minInterval, int maxInterval);
+    public void readGeneratedCommandListAttribute(
+        GeneratedCommandListAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
 
-    private native void readOutOfServiceAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
+    }
 
-    private native void writeOutOfServiceAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeGeneratedCommandListAttribute(
+        GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
 
-    private native void subscribeOutOfServiceAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readPolarityAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void readAcceptedCommandListAttribute(
+        AcceptedCommandListAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
 
-    private native void subscribePolarityAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
+    }
 
-    private native void readPresentValueAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
+    public void subscribeAcceptedCommandListAttribute(
+        AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
 
-    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 readReliabilityAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeReliabilityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeReliabilityAttribute(long chipClusterPtr, IntegerAttributeCallback 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 readApplicationTypeAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeApplicationTypeAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-  }
-
-  public static class PulseWidthModulationCluster extends BaseChipCluster {
-    public static final long CLUSTER_ID = 28L;
-
-    public PulseWidthModulationCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
-    }
-
-    @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
-
-    public interface GeneratedCommandListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface AcceptedCommandListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface EventListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface AttributeListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public void readGeneratedCommandListAttribute(
-        GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
-    }
-
-    public void subscribeGeneratedCommandListAttribute(
-        GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    public void readAcceptedCommandListAttribute(
-        AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
-    }
-
-    public void subscribeAcceptedCommandListAttribute(
-        AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class DescriptorCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 29L;
 
+    private static final long DEVICE_TYPE_LIST_ATTRIBUTE_ID = 0L;
+    private static final long SERVER_LIST_ATTRIBUTE_ID = 1L;
+    private static final long CLIENT_LIST_ATTRIBUTE_ID = 2L;
+    private static final long PARTS_LIST_ATTRIBUTE_ID = 3L;
+    private static final long TAG_LIST_ATTRIBUTE_ID = 4L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public DescriptorCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface DeviceTypeListAttributeCallback {
+    public interface DeviceTypeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.DescriptorClusterDeviceTypeStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ServerListAttributeCallback {
+    public interface ServerListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ClientListAttributeCallback {
+    public interface ClientListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface PartsListAttributeCallback {
+    public interface PartsListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Integer> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface TagListAttributeCallback {
+    public interface TagListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.DescriptorClusterSemanticTagStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readDeviceTypeListAttribute(
         DeviceTypeListAttributeCallback callback) {
-        readDeviceTypeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DEVICE_TYPE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.DescriptorClusterDeviceTypeStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DEVICE_TYPE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDeviceTypeListAttribute(
         DeviceTypeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDeviceTypeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DEVICE_TYPE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.DescriptorClusterDeviceTypeStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DEVICE_TYPE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readServerListAttribute(
         ServerListAttributeCallback callback) {
-        readServerListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SERVER_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SERVER_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeServerListAttribute(
         ServerListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeServerListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SERVER_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SERVER_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClientListAttribute(
         ClientListAttributeCallback callback) {
-        readClientListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLIENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLIENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClientListAttribute(
         ClientListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClientListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLIENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLIENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPartsListAttribute(
         PartsListAttributeCallback callback) {
-        readPartsListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PARTS_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PARTS_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribePartsListAttribute(
         PartsListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePartsListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PARTS_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PARTS_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTagListAttribute(
         TagListAttributeCallback callback) {
-        readTagListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TAG_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.DescriptorClusterSemanticTagStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TAG_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTagListAttribute(
         TagListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTagListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TAG_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.DescriptorClusterSemanticTagStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TAG_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readDeviceTypeListAttribute(long chipClusterPtr, DeviceTypeListAttributeCallback callback);
-
-    private native void subscribeDeviceTypeListAttribute(long chipClusterPtr, DeviceTypeListAttributeCallback 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 readTagListAttribute(long chipClusterPtr, TagListAttributeCallback callback);
-
-    private native void subscribeTagListAttribute(long chipClusterPtr, TagListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class BindingCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 30L;
 
+    private static final long BINDING_ATTRIBUTE_ID = 0L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public BindingCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface BindingAttributeCallback {
+    public interface BindingAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.BindingClusterTargetStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readBindingAttribute(
         BindingAttributeCallback callback) {
-        readBindingAttribute(chipClusterPtr, callback, true);
+      readBindingAttributeWithFabricFilter(callback, true);
     }
 
     public void readBindingAttributeWithFabricFilter(
         BindingAttributeCallback callback, boolean isFabricFiltered) {
-        readBindingAttribute(chipClusterPtr, callback, isFabricFiltered);
-    }
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BINDING_ATTRIBUTE_ID);
 
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.BindingClusterTargetStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BINDING_ATTRIBUTE_ID, isFabricFiltered);
+    }
 
     public void writeBindingAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.BindingClusterTargetStruct> value) {
-        writeBindingAttribute(chipClusterPtr, callback, value, null);
+      writeBindingAttribute(callback, value, 0);
     }
 
     public void writeBindingAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.BindingClusterTargetStruct> value, int timedWriteTimeoutMs) {
-        writeBindingAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = ArrayType.generateArrayType(value, (elementvalue) -> elementvalue.encodeTlv());
+      writeAttribute(new WriteAttributesCallbackImpl(callback), BINDING_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeBindingAttribute(
         BindingAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBindingAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BINDING_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.BindingClusterTargetStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BINDING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readBindingAttribute(long chipClusterPtr, BindingAttributeCallback callback, boolean isFabricFiltered);
-
-    private native void writeBindingAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList<ChipStructs.BindingClusterTargetStruct> value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeBindingAttribute(long chipClusterPtr, BindingAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class AccessControlCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 31L;
 
+    private static final long ACL_ATTRIBUTE_ID = 0L;
+    private static final long EXTENSION_ATTRIBUTE_ID = 1L;
+    private static final long SUBJECTS_PER_ACCESS_CONTROL_ENTRY_ATTRIBUTE_ID = 2L;
+    private static final long TARGETS_PER_ACCESS_CONTROL_ENTRY_ATTRIBUTE_ID = 3L;
+    private static final long ACCESS_CONTROL_ENTRIES_PER_FABRIC_ATTRIBUTE_ID = 4L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public AccessControlCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface AclAttributeCallback {
+    public interface AclAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.AccessControlClusterAccessControlEntryStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ExtensionAttributeCallback {
+    public interface ExtensionAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.AccessControlClusterAccessControlExtensionStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readAclAttribute(
         AclAttributeCallback callback) {
-        readAclAttribute(chipClusterPtr, callback, true);
+      readAclAttributeWithFabricFilter(callback, true);
     }
 
     public void readAclAttributeWithFabricFilter(
         AclAttributeCallback callback, boolean isFabricFiltered) {
-        readAclAttribute(chipClusterPtr, callback, isFabricFiltered);
-    }
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACL_ATTRIBUTE_ID);
 
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.AccessControlClusterAccessControlEntryStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACL_ATTRIBUTE_ID, isFabricFiltered);
+    }
 
     public void writeAclAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.AccessControlClusterAccessControlEntryStruct> value) {
-        writeAclAttribute(chipClusterPtr, callback, value, null);
+      writeAclAttribute(callback, value, 0);
     }
 
     public void writeAclAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.AccessControlClusterAccessControlEntryStruct> value, int timedWriteTimeoutMs) {
-        writeAclAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = ArrayType.generateArrayType(value, (elementvalue) -> elementvalue.encodeTlv());
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ACL_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeAclAttribute(
         AclAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAclAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACL_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.AccessControlClusterAccessControlEntryStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACL_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readExtensionAttribute(
         ExtensionAttributeCallback callback) {
-        readExtensionAttribute(chipClusterPtr, callback, true);
+      readExtensionAttributeWithFabricFilter(callback, true);
     }
 
     public void readExtensionAttributeWithFabricFilter(
         ExtensionAttributeCallback callback, boolean isFabricFiltered) {
-        readExtensionAttribute(chipClusterPtr, callback, isFabricFiltered);
-    }
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EXTENSION_ATTRIBUTE_ID);
 
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.AccessControlClusterAccessControlExtensionStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EXTENSION_ATTRIBUTE_ID, isFabricFiltered);
+    }
 
     public void writeExtensionAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.AccessControlClusterAccessControlExtensionStruct> value) {
-        writeExtensionAttribute(chipClusterPtr, callback, value, null);
+      writeExtensionAttribute(callback, value, 0);
     }
 
     public void writeExtensionAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.AccessControlClusterAccessControlExtensionStruct> value, int timedWriteTimeoutMs) {
-        writeExtensionAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = ArrayType.generateArrayType(value, (elementvalue) -> elementvalue.encodeTlv());
+      writeAttribute(new WriteAttributesCallbackImpl(callback), EXTENSION_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeExtensionAttribute(
         ExtensionAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeExtensionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EXTENSION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.AccessControlClusterAccessControlExtensionStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EXTENSION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSubjectsPerAccessControlEntryAttribute(
         IntegerAttributeCallback callback) {
-        readSubjectsPerAccessControlEntryAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUBJECTS_PER_ACCESS_CONTROL_ENTRY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SUBJECTS_PER_ACCESS_CONTROL_ENTRY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSubjectsPerAccessControlEntryAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSubjectsPerAccessControlEntryAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUBJECTS_PER_ACCESS_CONTROL_ENTRY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SUBJECTS_PER_ACCESS_CONTROL_ENTRY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTargetsPerAccessControlEntryAttribute(
         IntegerAttributeCallback callback) {
-        readTargetsPerAccessControlEntryAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TARGETS_PER_ACCESS_CONTROL_ENTRY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TARGETS_PER_ACCESS_CONTROL_ENTRY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTargetsPerAccessControlEntryAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTargetsPerAccessControlEntryAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TARGETS_PER_ACCESS_CONTROL_ENTRY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TARGETS_PER_ACCESS_CONTROL_ENTRY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAccessControlEntriesPerFabricAttribute(
         IntegerAttributeCallback callback) {
-        readAccessControlEntriesPerFabricAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCESS_CONTROL_ENTRIES_PER_FABRIC_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCESS_CONTROL_ENTRIES_PER_FABRIC_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAccessControlEntriesPerFabricAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAccessControlEntriesPerFabricAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCESS_CONTROL_ENTRIES_PER_FABRIC_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCESS_CONTROL_ENTRIES_PER_FABRIC_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readAclAttribute(long chipClusterPtr, AclAttributeCallback callback, boolean isFabricFiltered);
-
-    private native void writeAclAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList<ChipStructs.AccessControlClusterAccessControlEntryStruct> value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeAclAttribute(long chipClusterPtr, AclAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readExtensionAttribute(long chipClusterPtr, ExtensionAttributeCallback callback, boolean isFabricFiltered);
-
-    private native void writeExtensionAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList<ChipStructs.AccessControlClusterAccessControlExtensionStruct> value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeExtensionAttribute(long chipClusterPtr, ExtensionAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSubjectsPerAccessControlEntryAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeSubjectsPerAccessControlEntryAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readTargetsPerAccessControlEntryAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeTargetsPerAccessControlEntryAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAccessControlEntriesPerFabricAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeAccessControlEntriesPerFabricAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class ActionsCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 37L;
 
+    private static final long ACTION_LIST_ATTRIBUTE_ID = 0L;
+    private static final long ENDPOINT_LISTS_ATTRIBUTE_ID = 1L;
+    private static final long SETUP_U_R_L_ATTRIBUTE_ID = 2L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public ActionsCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void instantAction(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID) {
-      instantAction(chipClusterPtr, callback, actionID, invokeID, null);
+      instantAction(callback, actionID, invokeID, 0);
     }
 
     public void instantAction(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, int timedInvokeTimeoutMs) {
-      instantAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long actionIDFieldID = 0L;
+      BaseTLVType actionIDtlvValue = new UIntType(actionID);
+      elements.add(new StructElement(actionIDFieldID, actionIDtlvValue));
+
+      final long invokeIDFieldID = 1L;
+      BaseTLVType invokeIDtlvValue = invokeID.<BaseTLVType>map((nonOptionalinvokeID) -> new UIntType(nonOptionalinvokeID)).orElse(new EmptyType());
+      elements.add(new StructElement(invokeIDFieldID, invokeIDtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void instantActionWithTransition(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, Integer transitionTime) {
-      instantActionWithTransition(chipClusterPtr, callback, actionID, invokeID, transitionTime, null);
+      instantActionWithTransition(callback, actionID, invokeID, transitionTime, 0);
     }
 
     public void instantActionWithTransition(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, Integer transitionTime, int timedInvokeTimeoutMs) {
-      instantActionWithTransition(chipClusterPtr, callback, actionID, invokeID, transitionTime, timedInvokeTimeoutMs);
+      final long commandId = 1L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long actionIDFieldID = 0L;
+      BaseTLVType actionIDtlvValue = new UIntType(actionID);
+      elements.add(new StructElement(actionIDFieldID, actionIDtlvValue));
+
+      final long invokeIDFieldID = 1L;
+      BaseTLVType invokeIDtlvValue = invokeID.<BaseTLVType>map((nonOptionalinvokeID) -> new UIntType(nonOptionalinvokeID)).orElse(new EmptyType());
+      elements.add(new StructElement(invokeIDFieldID, invokeIDtlvValue));
+
+      final long transitionTimeFieldID = 2L;
+      BaseTLVType transitionTimetlvValue = new UIntType(transitionTime);
+      elements.add(new StructElement(transitionTimeFieldID, transitionTimetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void startAction(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID) {
-      startAction(chipClusterPtr, callback, actionID, invokeID, null);
+      startAction(callback, actionID, invokeID, 0);
     }
 
     public void startAction(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, int timedInvokeTimeoutMs) {
-      startAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs);
+      final long commandId = 2L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long actionIDFieldID = 0L;
+      BaseTLVType actionIDtlvValue = new UIntType(actionID);
+      elements.add(new StructElement(actionIDFieldID, actionIDtlvValue));
+
+      final long invokeIDFieldID = 1L;
+      BaseTLVType invokeIDtlvValue = invokeID.<BaseTLVType>map((nonOptionalinvokeID) -> new UIntType(nonOptionalinvokeID)).orElse(new EmptyType());
+      elements.add(new StructElement(invokeIDFieldID, invokeIDtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void startActionWithDuration(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, Long duration) {
-      startActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null);
+      startActionWithDuration(callback, actionID, invokeID, duration, 0);
     }
 
     public void startActionWithDuration(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, Long duration, int timedInvokeTimeoutMs) {
-      startActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs);
+      final long commandId = 3L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long actionIDFieldID = 0L;
+      BaseTLVType actionIDtlvValue = new UIntType(actionID);
+      elements.add(new StructElement(actionIDFieldID, actionIDtlvValue));
+
+      final long invokeIDFieldID = 1L;
+      BaseTLVType invokeIDtlvValue = invokeID.<BaseTLVType>map((nonOptionalinvokeID) -> new UIntType(nonOptionalinvokeID)).orElse(new EmptyType());
+      elements.add(new StructElement(invokeIDFieldID, invokeIDtlvValue));
+
+      final long durationFieldID = 2L;
+      BaseTLVType durationtlvValue = new UIntType(duration);
+      elements.add(new StructElement(durationFieldID, durationtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void stopAction(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID) {
-      stopAction(chipClusterPtr, callback, actionID, invokeID, null);
+      stopAction(callback, actionID, invokeID, 0);
     }
 
     public void stopAction(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, int timedInvokeTimeoutMs) {
-      stopAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs);
+      final long commandId = 4L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long actionIDFieldID = 0L;
+      BaseTLVType actionIDtlvValue = new UIntType(actionID);
+      elements.add(new StructElement(actionIDFieldID, actionIDtlvValue));
+
+      final long invokeIDFieldID = 1L;
+      BaseTLVType invokeIDtlvValue = invokeID.<BaseTLVType>map((nonOptionalinvokeID) -> new UIntType(nonOptionalinvokeID)).orElse(new EmptyType());
+      elements.add(new StructElement(invokeIDFieldID, invokeIDtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void pauseAction(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID) {
-      pauseAction(chipClusterPtr, callback, actionID, invokeID, null);
+      pauseAction(callback, actionID, invokeID, 0);
     }
 
     public void pauseAction(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, int timedInvokeTimeoutMs) {
-      pauseAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs);
+      final long commandId = 5L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long actionIDFieldID = 0L;
+      BaseTLVType actionIDtlvValue = new UIntType(actionID);
+      elements.add(new StructElement(actionIDFieldID, actionIDtlvValue));
+
+      final long invokeIDFieldID = 1L;
+      BaseTLVType invokeIDtlvValue = invokeID.<BaseTLVType>map((nonOptionalinvokeID) -> new UIntType(nonOptionalinvokeID)).orElse(new EmptyType());
+      elements.add(new StructElement(invokeIDFieldID, invokeIDtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void pauseActionWithDuration(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, Long duration) {
-      pauseActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null);
+      pauseActionWithDuration(callback, actionID, invokeID, duration, 0);
     }
 
     public void pauseActionWithDuration(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, Long duration, int timedInvokeTimeoutMs) {
-      pauseActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs);
+      final long commandId = 6L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long actionIDFieldID = 0L;
+      BaseTLVType actionIDtlvValue = new UIntType(actionID);
+      elements.add(new StructElement(actionIDFieldID, actionIDtlvValue));
+
+      final long invokeIDFieldID = 1L;
+      BaseTLVType invokeIDtlvValue = invokeID.<BaseTLVType>map((nonOptionalinvokeID) -> new UIntType(nonOptionalinvokeID)).orElse(new EmptyType());
+      elements.add(new StructElement(invokeIDFieldID, invokeIDtlvValue));
+
+      final long durationFieldID = 2L;
+      BaseTLVType durationtlvValue = new UIntType(duration);
+      elements.add(new StructElement(durationFieldID, durationtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void resumeAction(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID) {
-      resumeAction(chipClusterPtr, callback, actionID, invokeID, null);
+      resumeAction(callback, actionID, invokeID, 0);
     }
 
     public void resumeAction(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, int timedInvokeTimeoutMs) {
-      resumeAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs);
+      final long commandId = 7L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long actionIDFieldID = 0L;
+      BaseTLVType actionIDtlvValue = new UIntType(actionID);
+      elements.add(new StructElement(actionIDFieldID, actionIDtlvValue));
+
+      final long invokeIDFieldID = 1L;
+      BaseTLVType invokeIDtlvValue = invokeID.<BaseTLVType>map((nonOptionalinvokeID) -> new UIntType(nonOptionalinvokeID)).orElse(new EmptyType());
+      elements.add(new StructElement(invokeIDFieldID, invokeIDtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void enableAction(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID) {
-      enableAction(chipClusterPtr, callback, actionID, invokeID, null);
+      enableAction(callback, actionID, invokeID, 0);
     }
 
     public void enableAction(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, int timedInvokeTimeoutMs) {
-      enableAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs);
+      final long commandId = 8L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long actionIDFieldID = 0L;
+      BaseTLVType actionIDtlvValue = new UIntType(actionID);
+      elements.add(new StructElement(actionIDFieldID, actionIDtlvValue));
+
+      final long invokeIDFieldID = 1L;
+      BaseTLVType invokeIDtlvValue = invokeID.<BaseTLVType>map((nonOptionalinvokeID) -> new UIntType(nonOptionalinvokeID)).orElse(new EmptyType());
+      elements.add(new StructElement(invokeIDFieldID, invokeIDtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void enableActionWithDuration(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, Long duration) {
-      enableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null);
+      enableActionWithDuration(callback, actionID, invokeID, duration, 0);
     }
 
     public void enableActionWithDuration(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, Long duration, int timedInvokeTimeoutMs) {
-      enableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs);
-    }
+      final long commandId = 9L;
 
-    public void disableAction(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID) {
-      disableAction(chipClusterPtr, callback, actionID, invokeID, null);
-    }
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long actionIDFieldID = 0L;
+      BaseTLVType actionIDtlvValue = new UIntType(actionID);
+      elements.add(new StructElement(actionIDFieldID, actionIDtlvValue));
 
-    public void disableAction(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, int timedInvokeTimeoutMs) {
-      disableAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs);
-    }
+      final long invokeIDFieldID = 1L;
+      BaseTLVType invokeIDtlvValue = invokeID.<BaseTLVType>map((nonOptionalinvokeID) -> new UIntType(nonOptionalinvokeID)).orElse(new EmptyType());
+      elements.add(new StructElement(invokeIDFieldID, invokeIDtlvValue));
 
-    public void disableActionWithDuration(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, Long duration) {
-      disableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null);
-    }
+      final long durationFieldID = 2L;
+      BaseTLVType durationtlvValue = new UIntType(duration);
+      elements.add(new StructElement(durationFieldID, durationtlvValue));
 
-    public void disableActionWithDuration(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, Long duration, int timedInvokeTimeoutMs) {
-      disableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
-    private native void instantAction(long chipClusterPtr, DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void instantActionWithTransition(long chipClusterPtr, DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, Integer transitionTime, @Nullable Integer timedInvokeTimeoutMs);
+    public void disableAction(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID) {
+      disableAction(callback, actionID, invokeID, 0);
+    }
 
-    private native void startAction(long chipClusterPtr, DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, @Nullable Integer timedInvokeTimeoutMs);
+    public void disableAction(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, int timedInvokeTimeoutMs) {
+      final long commandId = 10L;
 
-    private native void startActionWithDuration(long chipClusterPtr, DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, Long duration, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long actionIDFieldID = 0L;
+      BaseTLVType actionIDtlvValue = new UIntType(actionID);
+      elements.add(new StructElement(actionIDFieldID, actionIDtlvValue));
 
-    private native void stopAction(long chipClusterPtr, DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, @Nullable Integer timedInvokeTimeoutMs);
+      final long invokeIDFieldID = 1L;
+      BaseTLVType invokeIDtlvValue = invokeID.<BaseTLVType>map((nonOptionalinvokeID) -> new UIntType(nonOptionalinvokeID)).orElse(new EmptyType());
+      elements.add(new StructElement(invokeIDFieldID, invokeIDtlvValue));
 
-    private native void pauseAction(long chipClusterPtr, DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, @Nullable Integer timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void pauseActionWithDuration(long chipClusterPtr, DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, Long duration, @Nullable Integer timedInvokeTimeoutMs);
+    public void disableActionWithDuration(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, Long duration) {
+      disableActionWithDuration(callback, actionID, invokeID, duration, 0);
+    }
 
-    private native void resumeAction(long chipClusterPtr, DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, @Nullable Integer timedInvokeTimeoutMs);
+    public void disableActionWithDuration(DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, Long duration, int timedInvokeTimeoutMs) {
+      final long commandId = 11L;
 
-    private native void enableAction(long chipClusterPtr, DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long actionIDFieldID = 0L;
+      BaseTLVType actionIDtlvValue = new UIntType(actionID);
+      elements.add(new StructElement(actionIDFieldID, actionIDtlvValue));
 
-    private native void enableActionWithDuration(long chipClusterPtr, DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, Long duration, @Nullable Integer timedInvokeTimeoutMs);
+      final long invokeIDFieldID = 1L;
+      BaseTLVType invokeIDtlvValue = invokeID.<BaseTLVType>map((nonOptionalinvokeID) -> new UIntType(nonOptionalinvokeID)).orElse(new EmptyType());
+      elements.add(new StructElement(invokeIDFieldID, invokeIDtlvValue));
 
-    private native void disableAction(long chipClusterPtr, DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, @Nullable Integer timedInvokeTimeoutMs);
+      final long durationFieldID = 2L;
+      BaseTLVType durationtlvValue = new UIntType(duration);
+      elements.add(new StructElement(durationFieldID, durationtlvValue));
 
-    private native void disableActionWithDuration(long chipClusterPtr, DefaultClusterCallback callback, Integer actionID, Optional<Long> invokeID, Long duration, @Nullable Integer timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface ActionListAttributeCallback {
+    public interface ActionListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.ActionsClusterActionStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EndpointListsAttributeCallback {
+    public interface EndpointListsAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.ActionsClusterEndpointListStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readActionListAttribute(
         ActionListAttributeCallback callback) {
-        readActionListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTION_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.ActionsClusterActionStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTION_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActionListAttribute(
         ActionListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActionListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTION_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.ActionsClusterActionStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTION_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEndpointListsAttribute(
         EndpointListsAttributeCallback callback) {
-        readEndpointListsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENDPOINT_LISTS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.ActionsClusterEndpointListStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ENDPOINT_LISTS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEndpointListsAttribute(
         EndpointListsAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEndpointListsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENDPOINT_LISTS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.ActionsClusterEndpointListStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ENDPOINT_LISTS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSetupURLAttribute(
         CharStringAttributeCallback callback) {
-        readSetupURLAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SETUP_U_R_L_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SETUP_U_R_L_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSetupURLAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSetupURLAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SETUP_U_R_L_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SETUP_U_R_L_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readEndpointListsAttribute(long chipClusterPtr, EndpointListsAttributeCallback callback);
-
-    private native void subscribeEndpointListsAttribute(long chipClusterPtr, EndpointListsAttributeCallback 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 readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class BasicInformationCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 40L;
 
+    private static final long DATA_MODEL_REVISION_ATTRIBUTE_ID = 0L;
+    private static final long VENDOR_NAME_ATTRIBUTE_ID = 1L;
+    private static final long VENDOR_I_D_ATTRIBUTE_ID = 2L;
+    private static final long PRODUCT_NAME_ATTRIBUTE_ID = 3L;
+    private static final long PRODUCT_I_D_ATTRIBUTE_ID = 4L;
+    private static final long NODE_LABEL_ATTRIBUTE_ID = 5L;
+    private static final long LOCATION_ATTRIBUTE_ID = 6L;
+    private static final long HARDWARE_VERSION_ATTRIBUTE_ID = 7L;
+    private static final long HARDWARE_VERSION_STRING_ATTRIBUTE_ID = 8L;
+    private static final long SOFTWARE_VERSION_ATTRIBUTE_ID = 9L;
+    private static final long SOFTWARE_VERSION_STRING_ATTRIBUTE_ID = 10L;
+    private static final long MANUFACTURING_DATE_ATTRIBUTE_ID = 11L;
+    private static final long PART_NUMBER_ATTRIBUTE_ID = 12L;
+    private static final long PRODUCT_U_R_L_ATTRIBUTE_ID = 13L;
+    private static final long PRODUCT_LABEL_ATTRIBUTE_ID = 14L;
+    private static final long SERIAL_NUMBER_ATTRIBUTE_ID = 15L;
+    private static final long LOCAL_CONFIG_DISABLED_ATTRIBUTE_ID = 16L;
+    private static final long REACHABLE_ATTRIBUTE_ID = 17L;
+    private static final long UNIQUE_I_D_ATTRIBUTE_ID = 18L;
+    private static final long CAPABILITY_MINIMA_ATTRIBUTE_ID = 19L;
+    private static final long PRODUCT_APPEARANCE_ATTRIBUTE_ID = 20L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public BasicInformationCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void mfgSpecificPing(DefaultClusterCallback callback) {
-      mfgSpecificPing(chipClusterPtr, callback, null);
+      mfgSpecificPing(callback, 0);
     }
 
     public void mfgSpecificPing(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      mfgSpecificPing(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
+      final long commandId = 0L;
 
-    private native void mfgSpecificPing(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface CapabilityMinimaAttributeCallback {
+    public interface CapabilityMinimaAttributeCallback extends BaseAttributeCallback {
       void onSuccess(ChipStructs.BasicInformationClusterCapabilityMinimaStruct value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ProductAppearanceAttributeCallback {
+    public interface ProductAppearanceAttributeCallback extends BaseAttributeCallback {
       void onSuccess(ChipStructs.BasicInformationClusterProductAppearanceStruct value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readDataModelRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readDataModelRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DATA_MODEL_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DATA_MODEL_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDataModelRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDataModelRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DATA_MODEL_REVISION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DATA_MODEL_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readVendorNameAttribute(
         CharStringAttributeCallback callback) {
-        readVendorNameAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, VENDOR_NAME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, VENDOR_NAME_ATTRIBUTE_ID, true);
     }
 
     public void subscribeVendorNameAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeVendorNameAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, VENDOR_NAME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, VENDOR_NAME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readVendorIDAttribute(
         IntegerAttributeCallback callback) {
-        readVendorIDAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, VENDOR_I_D_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, VENDOR_I_D_ATTRIBUTE_ID, true);
     }
 
     public void subscribeVendorIDAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeVendorIDAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, VENDOR_I_D_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, VENDOR_I_D_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readProductNameAttribute(
         CharStringAttributeCallback callback) {
-        readProductNameAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRODUCT_NAME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRODUCT_NAME_ATTRIBUTE_ID, true);
     }
 
     public void subscribeProductNameAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeProductNameAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRODUCT_NAME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRODUCT_NAME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readProductIDAttribute(
         IntegerAttributeCallback callback) {
-        readProductIDAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRODUCT_I_D_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRODUCT_I_D_ATTRIBUTE_ID, true);
     }
 
     public void subscribeProductIDAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeProductIDAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRODUCT_I_D_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRODUCT_I_D_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readNodeLabelAttribute(
         CharStringAttributeCallback callback) {
-        readNodeLabelAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NODE_LABEL_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NODE_LABEL_ATTRIBUTE_ID, true);
     }
 
     public void writeNodeLabelAttribute(DefaultClusterCallback callback, String value) {
-        writeNodeLabelAttribute(chipClusterPtr, callback, value, null);
+      writeNodeLabelAttribute(callback, value, 0);
     }
 
     public void writeNodeLabelAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) {
-        writeNodeLabelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new StringType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NODE_LABEL_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeNodeLabelAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNodeLabelAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NODE_LABEL_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NODE_LABEL_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLocationAttribute(
         CharStringAttributeCallback callback) {
-        readLocationAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOCATION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LOCATION_ATTRIBUTE_ID, true);
     }
 
     public void writeLocationAttribute(DefaultClusterCallback callback, String value) {
-        writeLocationAttribute(chipClusterPtr, callback, value, null);
+      writeLocationAttribute(callback, value, 0);
     }
 
     public void writeLocationAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) {
-        writeLocationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new StringType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LOCATION_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeLocationAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLocationAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOCATION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LOCATION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readHardwareVersionAttribute(
         IntegerAttributeCallback callback) {
-        readHardwareVersionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, HARDWARE_VERSION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, HARDWARE_VERSION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeHardwareVersionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeHardwareVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, HARDWARE_VERSION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, HARDWARE_VERSION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readHardwareVersionStringAttribute(
         CharStringAttributeCallback callback) {
-        readHardwareVersionStringAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, HARDWARE_VERSION_STRING_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, HARDWARE_VERSION_STRING_ATTRIBUTE_ID, true);
     }
 
     public void subscribeHardwareVersionStringAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeHardwareVersionStringAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, HARDWARE_VERSION_STRING_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, HARDWARE_VERSION_STRING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSoftwareVersionAttribute(
         LongAttributeCallback callback) {
-        readSoftwareVersionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SOFTWARE_VERSION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SOFTWARE_VERSION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSoftwareVersionAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSoftwareVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SOFTWARE_VERSION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SOFTWARE_VERSION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSoftwareVersionStringAttribute(
         CharStringAttributeCallback callback) {
-        readSoftwareVersionStringAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SOFTWARE_VERSION_STRING_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SOFTWARE_VERSION_STRING_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSoftwareVersionStringAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSoftwareVersionStringAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SOFTWARE_VERSION_STRING_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SOFTWARE_VERSION_STRING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readManufacturingDateAttribute(
         CharStringAttributeCallback callback) {
-        readManufacturingDateAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MANUFACTURING_DATE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MANUFACTURING_DATE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeManufacturingDateAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeManufacturingDateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MANUFACTURING_DATE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MANUFACTURING_DATE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPartNumberAttribute(
         CharStringAttributeCallback callback) {
-        readPartNumberAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PART_NUMBER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PART_NUMBER_ATTRIBUTE_ID, true);
     }
 
     public void subscribePartNumberAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePartNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PART_NUMBER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PART_NUMBER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readProductURLAttribute(
         CharStringAttributeCallback callback) {
-        readProductURLAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRODUCT_U_R_L_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRODUCT_U_R_L_ATTRIBUTE_ID, true);
     }
 
     public void subscribeProductURLAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeProductURLAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRODUCT_U_R_L_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRODUCT_U_R_L_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readProductLabelAttribute(
         CharStringAttributeCallback callback) {
-        readProductLabelAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRODUCT_LABEL_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRODUCT_LABEL_ATTRIBUTE_ID, true);
     }
 
     public void subscribeProductLabelAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeProductLabelAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRODUCT_LABEL_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRODUCT_LABEL_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSerialNumberAttribute(
         CharStringAttributeCallback callback) {
-        readSerialNumberAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SERIAL_NUMBER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SERIAL_NUMBER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSerialNumberAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSerialNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SERIAL_NUMBER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SERIAL_NUMBER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLocalConfigDisabledAttribute(
         BooleanAttributeCallback callback) {
-        readLocalConfigDisabledAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOCAL_CONFIG_DISABLED_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LOCAL_CONFIG_DISABLED_ATTRIBUTE_ID, true);
     }
 
     public void writeLocalConfigDisabledAttribute(DefaultClusterCallback callback, Boolean value) {
-        writeLocalConfigDisabledAttribute(chipClusterPtr, callback, value, null);
+      writeLocalConfigDisabledAttribute(callback, value, 0);
     }
 
     public void writeLocalConfigDisabledAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
-        writeLocalConfigDisabledAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new BooleanType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LOCAL_CONFIG_DISABLED_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeLocalConfigDisabledAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLocalConfigDisabledAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOCAL_CONFIG_DISABLED_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LOCAL_CONFIG_DISABLED_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readReachableAttribute(
         BooleanAttributeCallback callback) {
-        readReachableAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REACHABLE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, REACHABLE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeReachableAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeReachableAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REACHABLE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, REACHABLE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUniqueIDAttribute(
         CharStringAttributeCallback callback) {
-        readUniqueIDAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNIQUE_I_D_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UNIQUE_I_D_ATTRIBUTE_ID, true);
     }
 
     public void subscribeUniqueIDAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUniqueIDAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNIQUE_I_D_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UNIQUE_I_D_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCapabilityMinimaAttribute(
         CapabilityMinimaAttributeCallback callback) {
-        readCapabilityMinimaAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CAPABILITY_MINIMA_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            ChipStructs.BasicInformationClusterCapabilityMinimaStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CAPABILITY_MINIMA_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCapabilityMinimaAttribute(
         CapabilityMinimaAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCapabilityMinimaAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CAPABILITY_MINIMA_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            ChipStructs.BasicInformationClusterCapabilityMinimaStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CAPABILITY_MINIMA_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readProductAppearanceAttribute(
         ProductAppearanceAttributeCallback callback) {
-        readProductAppearanceAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRODUCT_APPEARANCE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            ChipStructs.BasicInformationClusterProductAppearanceStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRODUCT_APPEARANCE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeProductAppearanceAttribute(
         ProductAppearanceAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeProductAppearanceAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRODUCT_APPEARANCE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            ChipStructs.BasicInformationClusterProductAppearanceStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRODUCT_APPEARANCE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readDataModelRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeDataModelRevisionAttribute(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 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);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    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 readCapabilityMinimaAttribute(long chipClusterPtr, CapabilityMinimaAttributeCallback callback);
-
-    private native void subscribeCapabilityMinimaAttribute(long chipClusterPtr, CapabilityMinimaAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readProductAppearanceAttribute(long chipClusterPtr, ProductAppearanceAttributeCallback callback);
-
-    private native void subscribeProductAppearanceAttribute(long chipClusterPtr, ProductAppearanceAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class OtaSoftwareUpdateProviderCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 41L;
 
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public OtaSoftwareUpdateProviderCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void queryImage(QueryImageResponseCallback callback, Integer vendorID, Integer productID, Long softwareVersion, ArrayList<Integer> protocolsSupported, Optional<Integer> hardwareVersion, Optional<String> location, Optional<Boolean> requestorCanConsent, Optional<byte[]> metadataForProvider) {
-      queryImage(chipClusterPtr, callback, vendorID, productID, softwareVersion, protocolsSupported, hardwareVersion, location, requestorCanConsent, metadataForProvider, null);
+      queryImage(callback, vendorID, productID, softwareVersion, protocolsSupported, hardwareVersion, location, requestorCanConsent, metadataForProvider, 0);
     }
 
     public void queryImage(QueryImageResponseCallback callback, Integer vendorID, Integer productID, Long softwareVersion, ArrayList<Integer> protocolsSupported, Optional<Integer> hardwareVersion, Optional<String> location, Optional<Boolean> requestorCanConsent, Optional<byte[]> metadataForProvider, int timedInvokeTimeoutMs) {
-      queryImage(chipClusterPtr, callback, vendorID, productID, softwareVersion, protocolsSupported, hardwareVersion, location, requestorCanConsent, metadataForProvider, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long vendorIDFieldID = 0L;
+      BaseTLVType vendorIDtlvValue = new UIntType(vendorID);
+      elements.add(new StructElement(vendorIDFieldID, vendorIDtlvValue));
+
+      final long productIDFieldID = 1L;
+      BaseTLVType productIDtlvValue = new UIntType(productID);
+      elements.add(new StructElement(productIDFieldID, productIDtlvValue));
+
+      final long softwareVersionFieldID = 2L;
+      BaseTLVType softwareVersiontlvValue = new UIntType(softwareVersion);
+      elements.add(new StructElement(softwareVersionFieldID, softwareVersiontlvValue));
+
+      final long protocolsSupportedFieldID = 3L;
+      BaseTLVType protocolsSupportedtlvValue = ArrayType.generateArrayType(protocolsSupported, (elementprotocolsSupported) -> new UIntType(elementprotocolsSupported));
+      elements.add(new StructElement(protocolsSupportedFieldID, protocolsSupportedtlvValue));
+
+      final long hardwareVersionFieldID = 4L;
+      BaseTLVType hardwareVersiontlvValue = hardwareVersion.<BaseTLVType>map((nonOptionalhardwareVersion) -> new UIntType(nonOptionalhardwareVersion)).orElse(new EmptyType());
+      elements.add(new StructElement(hardwareVersionFieldID, hardwareVersiontlvValue));
+
+      final long locationFieldID = 5L;
+      BaseTLVType locationtlvValue = location.<BaseTLVType>map((nonOptionallocation) -> new StringType(nonOptionallocation)).orElse(new EmptyType());
+      elements.add(new StructElement(locationFieldID, locationtlvValue));
+
+      final long requestorCanConsentFieldID = 6L;
+      BaseTLVType requestorCanConsenttlvValue = requestorCanConsent.<BaseTLVType>map((nonOptionalrequestorCanConsent) -> new BooleanType(nonOptionalrequestorCanConsent)).orElse(new EmptyType());
+      elements.add(new StructElement(requestorCanConsentFieldID, requestorCanConsenttlvValue));
+
+      final long metadataForProviderFieldID = 7L;
+      BaseTLVType metadataForProvidertlvValue = metadataForProvider.<BaseTLVType>map((nonOptionalmetadataForProvider) -> new ByteArrayType(nonOptionalmetadataForProvider)).orElse(new EmptyType());
+      elements.add(new StructElement(metadataForProviderFieldID, metadataForProvidertlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long delayedActionTimeFieldID = 1L;
+          Optional<Long> delayedActionTime = Optional.empty();
+          final long imageURIFieldID = 2L;
+          Optional<String> imageURI = Optional.empty();
+          final long softwareVersionFieldID = 3L;
+          Optional<Long> softwareVersion = Optional.empty();
+          final long softwareVersionStringFieldID = 4L;
+          Optional<String> softwareVersionString = Optional.empty();
+          final long updateTokenFieldID = 5L;
+          Optional<byte[]> updateToken = Optional.empty();
+          final long userConsentNeededFieldID = 6L;
+          Optional<Boolean> userConsentNeeded = Optional.empty();
+          final long metadataForRequestorFieldID = 7L;
+          Optional<byte[]> metadataForRequestor = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == delayedActionTimeFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                delayedActionTime = Optional.of(castingValue.value(Long.class));
+              }
+            } else if (element.contextTagNum() == imageURIFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                imageURI = Optional.of(castingValue.value(String.class));
+              }
+            } else if (element.contextTagNum() == softwareVersionFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                softwareVersion = Optional.of(castingValue.value(Long.class));
+              }
+            } else if (element.contextTagNum() == softwareVersionStringFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                softwareVersionString = Optional.of(castingValue.value(String.class));
+              }
+            } else if (element.contextTagNum() == updateTokenFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+                ByteArrayType castingValue = element.value(ByteArrayType.class);
+                updateToken = Optional.of(castingValue.value(byte[].class));
+              }
+            } else if (element.contextTagNum() == userConsentNeededFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                userConsentNeeded = Optional.of(castingValue.value(Boolean.class));
+              }
+            } else if (element.contextTagNum() == metadataForRequestorFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+                ByteArrayType castingValue = element.value(ByteArrayType.class);
+                metadataForRequestor = Optional.of(castingValue.value(byte[].class));
+              }
+            }
+          }
+          callback.onSuccess(status, delayedActionTime, imageURI, softwareVersion, softwareVersionString, updateToken, userConsentNeeded, metadataForRequestor);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void applyUpdateRequest(ApplyUpdateResponseCallback callback, byte[] updateToken, Long newVersion) {
-      applyUpdateRequest(chipClusterPtr, callback, updateToken, newVersion, null);
+      applyUpdateRequest(callback, updateToken, newVersion, 0);
     }
 
     public void applyUpdateRequest(ApplyUpdateResponseCallback callback, byte[] updateToken, Long newVersion, int timedInvokeTimeoutMs) {
-      applyUpdateRequest(chipClusterPtr, callback, updateToken, newVersion, timedInvokeTimeoutMs);
+      final long commandId = 2L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long updateTokenFieldID = 0L;
+      BaseTLVType updateTokentlvValue = new ByteArrayType(updateToken);
+      elements.add(new StructElement(updateTokenFieldID, updateTokentlvValue));
+
+      final long newVersionFieldID = 1L;
+      BaseTLVType newVersiontlvValue = new UIntType(newVersion);
+      elements.add(new StructElement(newVersionFieldID, newVersiontlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long actionFieldID = 0L;
+          Integer action = null;
+          final long delayedActionTimeFieldID = 1L;
+          Long delayedActionTime = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == actionFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                action = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == delayedActionTimeFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                delayedActionTime = castingValue.value(Long.class);
+              }
+            }
+          }
+          callback.onSuccess(action, delayedActionTime);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void notifyUpdateApplied(DefaultClusterCallback callback, byte[] updateToken, Long softwareVersion) {
-      notifyUpdateApplied(chipClusterPtr, callback, updateToken, softwareVersion, null);
+      notifyUpdateApplied(callback, updateToken, softwareVersion, 0);
     }
 
     public void notifyUpdateApplied(DefaultClusterCallback callback, byte[] updateToken, Long softwareVersion, int timedInvokeTimeoutMs) {
-      notifyUpdateApplied(chipClusterPtr, callback, updateToken, softwareVersion, timedInvokeTimeoutMs);
-    }
+      final long commandId = 4L;
 
-    private native void queryImage(long chipClusterPtr, QueryImageResponseCallback callback, Integer vendorID, Integer productID, Long softwareVersion, ArrayList<Integer> protocolsSupported, Optional<Integer> hardwareVersion, Optional<String> location, Optional<Boolean> requestorCanConsent, Optional<byte[]> metadataForProvider, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long updateTokenFieldID = 0L;
+      BaseTLVType updateTokentlvValue = new ByteArrayType(updateToken);
+      elements.add(new StructElement(updateTokenFieldID, updateTokentlvValue));
 
-    private native void applyUpdateRequest(long chipClusterPtr, ApplyUpdateResponseCallback callback, byte[] updateToken, Long newVersion, @Nullable Integer timedInvokeTimeoutMs);
+      final long softwareVersionFieldID = 1L;
+      BaseTLVType softwareVersiontlvValue = new UIntType(softwareVersion);
+      elements.add(new StructElement(softwareVersionFieldID, softwareVersiontlvValue));
 
-    private native void notifyUpdateApplied(long chipClusterPtr, DefaultClusterCallback callback, byte[] updateToken, Long softwareVersion, @Nullable Integer timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface QueryImageResponseCallback {
+    public interface QueryImageResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, Optional<Long> delayedActionTime, Optional<String> imageURI, Optional<Long> softwareVersion, Optional<String> softwareVersionString, Optional<byte[]> updateToken, Optional<Boolean> userConsentNeeded, Optional<byte[]> metadataForRequestor);
-      void onError(Exception error);
     }
 
-    public interface ApplyUpdateResponseCallback {
+    public interface ApplyUpdateResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer action, Long delayedActionTime);
-      void onError(Exception error);
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class OtaSoftwareUpdateRequestorCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 42L;
 
+    private static final long DEFAULT_O_T_A_PROVIDERS_ATTRIBUTE_ID = 0L;
+    private static final long UPDATE_POSSIBLE_ATTRIBUTE_ID = 1L;
+    private static final long UPDATE_STATE_ATTRIBUTE_ID = 2L;
+    private static final long UPDATE_STATE_PROGRESS_ATTRIBUTE_ID = 3L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public OtaSoftwareUpdateRequestorCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void announceOTAProvider(DefaultClusterCallback callback, Long providerNodeID, Integer vendorID, Integer announcementReason, Optional<byte[]> metadataForNode, Integer endpoint) {
-      announceOTAProvider(chipClusterPtr, callback, providerNodeID, vendorID, announcementReason, metadataForNode, endpoint, null);
+      announceOTAProvider(callback, providerNodeID, vendorID, announcementReason, metadataForNode, endpoint, 0);
     }
 
     public void announceOTAProvider(DefaultClusterCallback callback, Long providerNodeID, Integer vendorID, Integer announcementReason, Optional<byte[]> metadataForNode, Integer endpoint, int timedInvokeTimeoutMs) {
-      announceOTAProvider(chipClusterPtr, callback, providerNodeID, vendorID, announcementReason, metadataForNode, endpoint, timedInvokeTimeoutMs);
-    }
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long providerNodeIDFieldID = 0L;
+      BaseTLVType providerNodeIDtlvValue = new UIntType(providerNodeID);
+      elements.add(new StructElement(providerNodeIDFieldID, providerNodeIDtlvValue));
+
+      final long vendorIDFieldID = 1L;
+      BaseTLVType vendorIDtlvValue = new UIntType(vendorID);
+      elements.add(new StructElement(vendorIDFieldID, vendorIDtlvValue));
+
+      final long announcementReasonFieldID = 2L;
+      BaseTLVType announcementReasontlvValue = new UIntType(announcementReason);
+      elements.add(new StructElement(announcementReasonFieldID, announcementReasontlvValue));
+
+      final long metadataForNodeFieldID = 3L;
+      BaseTLVType metadataForNodetlvValue = metadataForNode.<BaseTLVType>map((nonOptionalmetadataForNode) -> new ByteArrayType(nonOptionalmetadataForNode)).orElse(new EmptyType());
+      elements.add(new StructElement(metadataForNodeFieldID, metadataForNodetlvValue));
+
+      final long endpointFieldID = 4L;
+      BaseTLVType endpointtlvValue = new UIntType(endpoint);
+      elements.add(new StructElement(endpointFieldID, endpointtlvValue));
 
-    private native void announceOTAProvider(long chipClusterPtr, DefaultClusterCallback callback, Long providerNodeID, Integer vendorID, Integer announcementReason, Optional<byte[]> metadataForNode, Integer endpoint, @Nullable Integer timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface DefaultOTAProvidersAttributeCallback {
+    public interface DefaultOTAProvidersAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.OtaSoftwareUpdateRequestorClusterProviderLocation> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface UpdateStateProgressAttributeCallback {
+    public interface UpdateStateProgressAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readDefaultOTAProvidersAttribute(
         DefaultOTAProvidersAttributeCallback callback) {
-        readDefaultOTAProvidersAttribute(chipClusterPtr, callback, true);
+      readDefaultOTAProvidersAttributeWithFabricFilter(callback, true);
     }
 
     public void readDefaultOTAProvidersAttributeWithFabricFilter(
         DefaultOTAProvidersAttributeCallback callback, boolean isFabricFiltered) {
-        readDefaultOTAProvidersAttribute(chipClusterPtr, callback, isFabricFiltered);
-    }
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DEFAULT_O_T_A_PROVIDERS_ATTRIBUTE_ID);
 
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.OtaSoftwareUpdateRequestorClusterProviderLocation> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DEFAULT_O_T_A_PROVIDERS_ATTRIBUTE_ID, isFabricFiltered);
+    }
 
     public void writeDefaultOTAProvidersAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.OtaSoftwareUpdateRequestorClusterProviderLocation> value) {
-        writeDefaultOTAProvidersAttribute(chipClusterPtr, callback, value, null);
+      writeDefaultOTAProvidersAttribute(callback, value, 0);
     }
 
     public void writeDefaultOTAProvidersAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.OtaSoftwareUpdateRequestorClusterProviderLocation> value, int timedWriteTimeoutMs) {
-        writeDefaultOTAProvidersAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = ArrayType.generateArrayType(value, (elementvalue) -> elementvalue.encodeTlv());
+      writeAttribute(new WriteAttributesCallbackImpl(callback), DEFAULT_O_T_A_PROVIDERS_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeDefaultOTAProvidersAttribute(
         DefaultOTAProvidersAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDefaultOTAProvidersAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DEFAULT_O_T_A_PROVIDERS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.OtaSoftwareUpdateRequestorClusterProviderLocation> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DEFAULT_O_T_A_PROVIDERS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUpdatePossibleAttribute(
         BooleanAttributeCallback callback) {
-        readUpdatePossibleAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UPDATE_POSSIBLE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UPDATE_POSSIBLE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeUpdatePossibleAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUpdatePossibleAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UPDATE_POSSIBLE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UPDATE_POSSIBLE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUpdateStateAttribute(
         IntegerAttributeCallback callback) {
-        readUpdateStateAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UPDATE_STATE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UPDATE_STATE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeUpdateStateAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUpdateStateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UPDATE_STATE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UPDATE_STATE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUpdateStateProgressAttribute(
         UpdateStateProgressAttributeCallback callback) {
-        readUpdateStateProgressAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UPDATE_STATE_PROGRESS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UPDATE_STATE_PROGRESS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeUpdateStateProgressAttribute(
         UpdateStateProgressAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUpdateStateProgressAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UPDATE_STATE_PROGRESS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UPDATE_STATE_PROGRESS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readDefaultOTAProvidersAttribute(long chipClusterPtr, DefaultOTAProvidersAttributeCallback callback, boolean isFabricFiltered);
-
-    private native void writeDefaultOTAProvidersAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList<ChipStructs.OtaSoftwareUpdateRequestorClusterProviderLocation> 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 readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    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);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class LocalizationConfigurationCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 43L;
 
+    private static final long ACTIVE_LOCALE_ATTRIBUTE_ID = 0L;
+    private static final long SUPPORTED_LOCALES_ATTRIBUTE_ID = 1L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public LocalizationConfigurationCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface SupportedLocalesAttributeCallback {
+    public interface SupportedLocalesAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<String> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readActiveLocaleAttribute(
         CharStringAttributeCallback callback) {
-        readActiveLocaleAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_LOCALE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_LOCALE_ATTRIBUTE_ID, true);
     }
 
     public void writeActiveLocaleAttribute(DefaultClusterCallback callback, String value) {
-        writeActiveLocaleAttribute(chipClusterPtr, callback, value, null);
+      writeActiveLocaleAttribute(callback, value, 0);
     }
 
     public void writeActiveLocaleAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) {
-        writeActiveLocaleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new StringType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ACTIVE_LOCALE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeActiveLocaleAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActiveLocaleAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_LOCALE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_LOCALE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSupportedLocalesAttribute(
         SupportedLocalesAttributeCallback callback) {
-        readSupportedLocalesAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_LOCALES_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<String> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SUPPORTED_LOCALES_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSupportedLocalesAttribute(
         SupportedLocalesAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSupportedLocalesAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_LOCALES_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<String> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SUPPORTED_LOCALES_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
+  }
 
-    private native void readActiveLocaleAttribute(long chipClusterPtr, CharStringAttributeCallback callback);
+  public static class TimeFormatLocalizationCluster extends BaseChipCluster {
+    public static final long CLUSTER_ID = 44L;
 
-    private native void writeActiveLocaleAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs);
+    private static final long HOUR_FORMAT_ATTRIBUTE_ID = 0L;
+    private static final long ACTIVE_CALENDAR_TYPE_ATTRIBUTE_ID = 1L;
+    private static final long SUPPORTED_CALENDAR_TYPES_ATTRIBUTE_ID = 2L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
 
-    private native void subscribeActiveLocaleAttribute(long chipClusterPtr, CharStringAttributeCallback callback, int minInterval, int maxInterval);
+    public TimeFormatLocalizationCluster(long devicePtr, int endpointId) {
+      super(devicePtr, endpointId, CLUSTER_ID);
+    }
 
-    private native void readSupportedLocalesAttribute(long chipClusterPtr, SupportedLocalesAttributeCallback callback);
+    @Override
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    private native void subscribeSupportedLocalesAttribute(long chipClusterPtr, SupportedLocalesAttributeCallback callback, int minInterval, int maxInterval);
+    public interface SupportedCalendarTypesAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Integer> value);
+    }
 
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-  }
-
-  public static class TimeFormatLocalizationCluster extends BaseChipCluster {
-    public static final long CLUSTER_ID = 44L;
-
-    public TimeFormatLocalizationCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
-    }
-
-    @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
-
-    public interface SupportedCalendarTypesAttributeCallback {
-      void onSuccess(List<Integer> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface GeneratedCommandListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readHourFormatAttribute(
         IntegerAttributeCallback callback) {
-        readHourFormatAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, HOUR_FORMAT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, HOUR_FORMAT_ATTRIBUTE_ID, true);
     }
 
     public void writeHourFormatAttribute(DefaultClusterCallback callback, Integer value) {
-        writeHourFormatAttribute(chipClusterPtr, callback, value, null);
+      writeHourFormatAttribute(callback, value, 0);
     }
 
     public void writeHourFormatAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeHourFormatAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), HOUR_FORMAT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeHourFormatAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeHourFormatAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, HOUR_FORMAT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, HOUR_FORMAT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActiveCalendarTypeAttribute(
         IntegerAttributeCallback callback) {
-        readActiveCalendarTypeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_CALENDAR_TYPE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_CALENDAR_TYPE_ATTRIBUTE_ID, true);
     }
 
     public void writeActiveCalendarTypeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeActiveCalendarTypeAttribute(chipClusterPtr, callback, value, null);
+      writeActiveCalendarTypeAttribute(callback, value, 0);
     }
 
     public void writeActiveCalendarTypeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeActiveCalendarTypeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ACTIVE_CALENDAR_TYPE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeActiveCalendarTypeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActiveCalendarTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_CALENDAR_TYPE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_CALENDAR_TYPE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSupportedCalendarTypesAttribute(
         SupportedCalendarTypesAttributeCallback callback) {
-        readSupportedCalendarTypesAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_CALENDAR_TYPES_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SUPPORTED_CALENDAR_TYPES_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSupportedCalendarTypesAttribute(
         SupportedCalendarTypesAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSupportedCalendarTypesAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_CALENDAR_TYPES_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SUPPORTED_CALENDAR_TYPES_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    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 readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class UnitLocalizationCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 45L;
 
+    private static final long TEMPERATURE_UNIT_ATTRIBUTE_ID = 0L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public UnitLocalizationCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readTemperatureUnitAttribute(
         IntegerAttributeCallback callback) {
-        readTemperatureUnitAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TEMPERATURE_UNIT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TEMPERATURE_UNIT_ATTRIBUTE_ID, true);
     }
 
     public void writeTemperatureUnitAttribute(DefaultClusterCallback callback, Integer value) {
-        writeTemperatureUnitAttribute(chipClusterPtr, callback, value, null);
+      writeTemperatureUnitAttribute(callback, value, 0);
     }
 
     public void writeTemperatureUnitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeTemperatureUnitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), TEMPERATURE_UNIT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeTemperatureUnitAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTemperatureUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TEMPERATURE_UNIT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TEMPERATURE_UNIT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    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 readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class PowerSourceConfigurationCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 46L;
 
+    private static final long SOURCES_ATTRIBUTE_ID = 0L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public PowerSourceConfigurationCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface SourcesAttributeCallback {
+    public interface SourcesAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Integer> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readSourcesAttribute(
         SourcesAttributeCallback callback) {
-        readSourcesAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SOURCES_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SOURCES_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSourcesAttribute(
         SourcesAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSourcesAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SOURCES_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SOURCES_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readSourcesAttribute(long chipClusterPtr, SourcesAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeSourcesAttribute(long chipClusterPtr, SourcesAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class PowerSourceCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 47L;
 
+    private static final long STATUS_ATTRIBUTE_ID = 0L;
+    private static final long ORDER_ATTRIBUTE_ID = 1L;
+    private static final long DESCRIPTION_ATTRIBUTE_ID = 2L;
+    private static final long WIRED_ASSESSED_INPUT_VOLTAGE_ATTRIBUTE_ID = 3L;
+    private static final long WIRED_ASSESSED_INPUT_FREQUENCY_ATTRIBUTE_ID = 4L;
+    private static final long WIRED_CURRENT_TYPE_ATTRIBUTE_ID = 5L;
+    private static final long WIRED_ASSESSED_CURRENT_ATTRIBUTE_ID = 6L;
+    private static final long WIRED_NOMINAL_VOLTAGE_ATTRIBUTE_ID = 7L;
+    private static final long WIRED_MAXIMUM_CURRENT_ATTRIBUTE_ID = 8L;
+    private static final long WIRED_PRESENT_ATTRIBUTE_ID = 9L;
+    private static final long ACTIVE_WIRED_FAULTS_ATTRIBUTE_ID = 10L;
+    private static final long BAT_VOLTAGE_ATTRIBUTE_ID = 11L;
+    private static final long BAT_PERCENT_REMAINING_ATTRIBUTE_ID = 12L;
+    private static final long BAT_TIME_REMAINING_ATTRIBUTE_ID = 13L;
+    private static final long BAT_CHARGE_LEVEL_ATTRIBUTE_ID = 14L;
+    private static final long BAT_REPLACEMENT_NEEDED_ATTRIBUTE_ID = 15L;
+    private static final long BAT_REPLACEABILITY_ATTRIBUTE_ID = 16L;
+    private static final long BAT_PRESENT_ATTRIBUTE_ID = 17L;
+    private static final long ACTIVE_BAT_FAULTS_ATTRIBUTE_ID = 18L;
+    private static final long BAT_REPLACEMENT_DESCRIPTION_ATTRIBUTE_ID = 19L;
+    private static final long BAT_COMMON_DESIGNATION_ATTRIBUTE_ID = 20L;
+    private static final long BAT_A_N_S_I_DESIGNATION_ATTRIBUTE_ID = 21L;
+    private static final long BAT_I_E_C_DESIGNATION_ATTRIBUTE_ID = 22L;
+    private static final long BAT_APPROVED_CHEMISTRY_ATTRIBUTE_ID = 23L;
+    private static final long BAT_CAPACITY_ATTRIBUTE_ID = 24L;
+    private static final long BAT_QUANTITY_ATTRIBUTE_ID = 25L;
+    private static final long BAT_CHARGE_STATE_ATTRIBUTE_ID = 26L;
+    private static final long BAT_TIME_TO_FULL_CHARGE_ATTRIBUTE_ID = 27L;
+    private static final long BAT_FUNCTIONAL_WHILE_CHARGING_ATTRIBUTE_ID = 28L;
+    private static final long BAT_CHARGING_CURRENT_ATTRIBUTE_ID = 29L;
+    private static final long ACTIVE_BAT_CHARGE_FAULTS_ATTRIBUTE_ID = 30L;
+    private static final long ENDPOINT_LIST_ATTRIBUTE_ID = 31L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public PowerSourceCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface WiredAssessedInputVoltageAttributeCallback {
+    public interface WiredAssessedInputVoltageAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface WiredAssessedInputFrequencyAttributeCallback {
+    public interface WiredAssessedInputFrequencyAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface WiredAssessedCurrentAttributeCallback {
+    public interface WiredAssessedCurrentAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ActiveWiredFaultsAttributeCallback {
+    public interface ActiveWiredFaultsAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Integer> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface BatVoltageAttributeCallback {
+    public interface BatVoltageAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface BatPercentRemainingAttributeCallback {
+    public interface BatPercentRemainingAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface BatTimeRemainingAttributeCallback {
+    public interface BatTimeRemainingAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ActiveBatFaultsAttributeCallback {
+    public interface ActiveBatFaultsAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Integer> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface BatTimeToFullChargeAttributeCallback {
+    public interface BatTimeToFullChargeAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface BatChargingCurrentAttributeCallback {
+    public interface BatChargingCurrentAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ActiveBatChargeFaultsAttributeCallback {
+    public interface ActiveBatChargeFaultsAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Integer> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EndpointListAttributeCallback {
+    public interface EndpointListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Integer> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readStatusAttribute(
         IntegerAttributeCallback callback) {
-        readStatusAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STATUS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, STATUS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeStatusAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STATUS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, STATUS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOrderAttribute(
         IntegerAttributeCallback callback) {
-        readOrderAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ORDER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ORDER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeOrderAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOrderAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ORDER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ORDER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDescriptionAttribute(
         CharStringAttributeCallback callback) {
-        readDescriptionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DESCRIPTION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DESCRIPTION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDescriptionAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDescriptionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DESCRIPTION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DESCRIPTION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readWiredAssessedInputVoltageAttribute(
         WiredAssessedInputVoltageAttributeCallback callback) {
-        readWiredAssessedInputVoltageAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WIRED_ASSESSED_INPUT_VOLTAGE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, WIRED_ASSESSED_INPUT_VOLTAGE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeWiredAssessedInputVoltageAttribute(
         WiredAssessedInputVoltageAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeWiredAssessedInputVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WIRED_ASSESSED_INPUT_VOLTAGE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, WIRED_ASSESSED_INPUT_VOLTAGE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readWiredAssessedInputFrequencyAttribute(
         WiredAssessedInputFrequencyAttributeCallback callback) {
-        readWiredAssessedInputFrequencyAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WIRED_ASSESSED_INPUT_FREQUENCY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, WIRED_ASSESSED_INPUT_FREQUENCY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeWiredAssessedInputFrequencyAttribute(
         WiredAssessedInputFrequencyAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeWiredAssessedInputFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WIRED_ASSESSED_INPUT_FREQUENCY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, WIRED_ASSESSED_INPUT_FREQUENCY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readWiredCurrentTypeAttribute(
         IntegerAttributeCallback callback) {
-        readWiredCurrentTypeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WIRED_CURRENT_TYPE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, WIRED_CURRENT_TYPE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeWiredCurrentTypeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeWiredCurrentTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WIRED_CURRENT_TYPE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, WIRED_CURRENT_TYPE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readWiredAssessedCurrentAttribute(
         WiredAssessedCurrentAttributeCallback callback) {
-        readWiredAssessedCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WIRED_ASSESSED_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, WIRED_ASSESSED_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeWiredAssessedCurrentAttribute(
         WiredAssessedCurrentAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeWiredAssessedCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WIRED_ASSESSED_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, WIRED_ASSESSED_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readWiredNominalVoltageAttribute(
         LongAttributeCallback callback) {
-        readWiredNominalVoltageAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WIRED_NOMINAL_VOLTAGE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, WIRED_NOMINAL_VOLTAGE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeWiredNominalVoltageAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeWiredNominalVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WIRED_NOMINAL_VOLTAGE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, WIRED_NOMINAL_VOLTAGE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readWiredMaximumCurrentAttribute(
         LongAttributeCallback callback) {
-        readWiredMaximumCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WIRED_MAXIMUM_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, WIRED_MAXIMUM_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeWiredMaximumCurrentAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeWiredMaximumCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WIRED_MAXIMUM_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, WIRED_MAXIMUM_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readWiredPresentAttribute(
         BooleanAttributeCallback callback) {
-        readWiredPresentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WIRED_PRESENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, WIRED_PRESENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeWiredPresentAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeWiredPresentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WIRED_PRESENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, WIRED_PRESENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActiveWiredFaultsAttribute(
         ActiveWiredFaultsAttributeCallback callback) {
-        readActiveWiredFaultsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_WIRED_FAULTS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_WIRED_FAULTS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActiveWiredFaultsAttribute(
         ActiveWiredFaultsAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActiveWiredFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_WIRED_FAULTS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_WIRED_FAULTS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBatVoltageAttribute(
         BatVoltageAttributeCallback callback) {
-        readBatVoltageAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_VOLTAGE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BAT_VOLTAGE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBatVoltageAttribute(
         BatVoltageAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBatVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_VOLTAGE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BAT_VOLTAGE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBatPercentRemainingAttribute(
         BatPercentRemainingAttributeCallback callback) {
-        readBatPercentRemainingAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_PERCENT_REMAINING_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BAT_PERCENT_REMAINING_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBatPercentRemainingAttribute(
         BatPercentRemainingAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBatPercentRemainingAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_PERCENT_REMAINING_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BAT_PERCENT_REMAINING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBatTimeRemainingAttribute(
         BatTimeRemainingAttributeCallback callback) {
-        readBatTimeRemainingAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_TIME_REMAINING_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BAT_TIME_REMAINING_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBatTimeRemainingAttribute(
         BatTimeRemainingAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBatTimeRemainingAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_TIME_REMAINING_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BAT_TIME_REMAINING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBatChargeLevelAttribute(
         IntegerAttributeCallback callback) {
-        readBatChargeLevelAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_CHARGE_LEVEL_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BAT_CHARGE_LEVEL_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBatChargeLevelAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBatChargeLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_CHARGE_LEVEL_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BAT_CHARGE_LEVEL_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBatReplacementNeededAttribute(
         BooleanAttributeCallback callback) {
-        readBatReplacementNeededAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_REPLACEMENT_NEEDED_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BAT_REPLACEMENT_NEEDED_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBatReplacementNeededAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBatReplacementNeededAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_REPLACEMENT_NEEDED_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BAT_REPLACEMENT_NEEDED_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBatReplaceabilityAttribute(
         IntegerAttributeCallback callback) {
-        readBatReplaceabilityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_REPLACEABILITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BAT_REPLACEABILITY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBatReplaceabilityAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBatReplaceabilityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_REPLACEABILITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BAT_REPLACEABILITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBatPresentAttribute(
         BooleanAttributeCallback callback) {
-        readBatPresentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_PRESENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BAT_PRESENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBatPresentAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBatPresentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_PRESENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BAT_PRESENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActiveBatFaultsAttribute(
         ActiveBatFaultsAttributeCallback callback) {
-        readActiveBatFaultsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_BAT_FAULTS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_BAT_FAULTS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActiveBatFaultsAttribute(
         ActiveBatFaultsAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActiveBatFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_BAT_FAULTS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_BAT_FAULTS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBatReplacementDescriptionAttribute(
         CharStringAttributeCallback callback) {
-        readBatReplacementDescriptionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_REPLACEMENT_DESCRIPTION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BAT_REPLACEMENT_DESCRIPTION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBatReplacementDescriptionAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBatReplacementDescriptionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_REPLACEMENT_DESCRIPTION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BAT_REPLACEMENT_DESCRIPTION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBatCommonDesignationAttribute(
         IntegerAttributeCallback callback) {
-        readBatCommonDesignationAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_COMMON_DESIGNATION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BAT_COMMON_DESIGNATION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBatCommonDesignationAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBatCommonDesignationAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_COMMON_DESIGNATION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BAT_COMMON_DESIGNATION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBatANSIDesignationAttribute(
         CharStringAttributeCallback callback) {
-        readBatANSIDesignationAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_A_N_S_I_DESIGNATION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BAT_A_N_S_I_DESIGNATION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBatANSIDesignationAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBatANSIDesignationAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_A_N_S_I_DESIGNATION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BAT_A_N_S_I_DESIGNATION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBatIECDesignationAttribute(
         CharStringAttributeCallback callback) {
-        readBatIECDesignationAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_I_E_C_DESIGNATION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BAT_I_E_C_DESIGNATION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBatIECDesignationAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBatIECDesignationAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_I_E_C_DESIGNATION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BAT_I_E_C_DESIGNATION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBatApprovedChemistryAttribute(
         IntegerAttributeCallback callback) {
-        readBatApprovedChemistryAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_APPROVED_CHEMISTRY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BAT_APPROVED_CHEMISTRY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBatApprovedChemistryAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBatApprovedChemistryAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_APPROVED_CHEMISTRY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BAT_APPROVED_CHEMISTRY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBatCapacityAttribute(
         LongAttributeCallback callback) {
-        readBatCapacityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_CAPACITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BAT_CAPACITY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBatCapacityAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBatCapacityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_CAPACITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BAT_CAPACITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBatQuantityAttribute(
         IntegerAttributeCallback callback) {
-        readBatQuantityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_QUANTITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BAT_QUANTITY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBatQuantityAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBatQuantityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_QUANTITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BAT_QUANTITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBatChargeStateAttribute(
         IntegerAttributeCallback callback) {
-        readBatChargeStateAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_CHARGE_STATE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BAT_CHARGE_STATE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBatChargeStateAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBatChargeStateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_CHARGE_STATE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BAT_CHARGE_STATE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBatTimeToFullChargeAttribute(
         BatTimeToFullChargeAttributeCallback callback) {
-        readBatTimeToFullChargeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_TIME_TO_FULL_CHARGE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BAT_TIME_TO_FULL_CHARGE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBatTimeToFullChargeAttribute(
         BatTimeToFullChargeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBatTimeToFullChargeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_TIME_TO_FULL_CHARGE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BAT_TIME_TO_FULL_CHARGE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBatFunctionalWhileChargingAttribute(
         BooleanAttributeCallback callback) {
-        readBatFunctionalWhileChargingAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_FUNCTIONAL_WHILE_CHARGING_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BAT_FUNCTIONAL_WHILE_CHARGING_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBatFunctionalWhileChargingAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBatFunctionalWhileChargingAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_FUNCTIONAL_WHILE_CHARGING_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BAT_FUNCTIONAL_WHILE_CHARGING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBatChargingCurrentAttribute(
         BatChargingCurrentAttributeCallback callback) {
-        readBatChargingCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_CHARGING_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BAT_CHARGING_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBatChargingCurrentAttribute(
         BatChargingCurrentAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBatChargingCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BAT_CHARGING_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BAT_CHARGING_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActiveBatChargeFaultsAttribute(
         ActiveBatChargeFaultsAttributeCallback callback) {
-        readActiveBatChargeFaultsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_BAT_CHARGE_FAULTS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_BAT_CHARGE_FAULTS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActiveBatChargeFaultsAttribute(
         ActiveBatChargeFaultsAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActiveBatChargeFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_BAT_CHARGE_FAULTS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_BAT_CHARGE_FAULTS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEndpointListAttribute(
         EndpointListAttributeCallback callback) {
-        readEndpointListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENDPOINT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ENDPOINT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEndpointListAttribute(
         EndpointListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEndpointListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENDPOINT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ENDPOINT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
+  }
 
-    private native void readStatusAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+  public static class GeneralCommissioningCluster extends BaseChipCluster {
+    public static final long CLUSTER_ID = 48L;
 
-    private native void subscribeStatusAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    private static final long BREADCRUMB_ATTRIBUTE_ID = 0L;
+    private static final long BASIC_COMMISSIONING_INFO_ATTRIBUTE_ID = 1L;
+    private static final long REGULATORY_CONFIG_ATTRIBUTE_ID = 2L;
+    private static final long LOCATION_CAPABILITY_ATTRIBUTE_ID = 3L;
+    private static final long SUPPORTS_CONCURRENT_CONNECTION_ATTRIBUTE_ID = 4L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
 
-    private native void readOrderAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public GeneralCommissioningCluster(long devicePtr, int endpointId) {
+      super(devicePtr, endpointId, CLUSTER_ID);
+    }
 
-    private native void subscribeOrderAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    @Override
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    private native void readDescriptionAttribute(long chipClusterPtr, CharStringAttributeCallback callback);
+    public void armFailSafe(ArmFailSafeResponseCallback callback, Integer expiryLengthSeconds, Long breadcrumb) {
+      armFailSafe(callback, expiryLengthSeconds, breadcrumb, 0);
+    }
 
-    private native void subscribeDescriptionAttribute(long chipClusterPtr, CharStringAttributeCallback callback, int minInterval, int maxInterval);
+    public void armFailSafe(ArmFailSafeResponseCallback callback, Integer expiryLengthSeconds, Long breadcrumb, int timedInvokeTimeoutMs) {
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long expiryLengthSecondsFieldID = 0L;
+      BaseTLVType expiryLengthSecondstlvValue = new UIntType(expiryLengthSeconds);
+      elements.add(new StructElement(expiryLengthSecondsFieldID, expiryLengthSecondstlvValue));
+
+      final long breadcrumbFieldID = 1L;
+      BaseTLVType breadcrumbtlvValue = new UIntType(breadcrumb);
+      elements.add(new StructElement(breadcrumbFieldID, breadcrumbtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long errorCodeFieldID = 0L;
+          Integer errorCode = null;
+          final long debugTextFieldID = 1L;
+          String debugText = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == errorCodeFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                errorCode = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == debugTextFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                debugText = castingValue.value(String.class);
+              }
+            }
+          }
+          callback.onSuccess(errorCode, debugText);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void readWiredAssessedInputVoltageAttribute(long chipClusterPtr, WiredAssessedInputVoltageAttributeCallback callback);
+    public void setRegulatoryConfig(SetRegulatoryConfigResponseCallback callback, Integer newRegulatoryConfig, String countryCode, Long breadcrumb) {
+      setRegulatoryConfig(callback, newRegulatoryConfig, countryCode, breadcrumb, 0);
+    }
 
-    private native void subscribeWiredAssessedInputVoltageAttribute(long chipClusterPtr, WiredAssessedInputVoltageAttributeCallback callback, int minInterval, int maxInterval);
+    public void setRegulatoryConfig(SetRegulatoryConfigResponseCallback callback, Integer newRegulatoryConfig, String countryCode, Long breadcrumb, int timedInvokeTimeoutMs) {
+      final long commandId = 2L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long newRegulatoryConfigFieldID = 0L;
+      BaseTLVType newRegulatoryConfigtlvValue = new UIntType(newRegulatoryConfig);
+      elements.add(new StructElement(newRegulatoryConfigFieldID, newRegulatoryConfigtlvValue));
+
+      final long countryCodeFieldID = 1L;
+      BaseTLVType countryCodetlvValue = new StringType(countryCode);
+      elements.add(new StructElement(countryCodeFieldID, countryCodetlvValue));
+
+      final long breadcrumbFieldID = 2L;
+      BaseTLVType breadcrumbtlvValue = new UIntType(breadcrumb);
+      elements.add(new StructElement(breadcrumbFieldID, breadcrumbtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long errorCodeFieldID = 0L;
+          Integer errorCode = null;
+          final long debugTextFieldID = 1L;
+          String debugText = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == errorCodeFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                errorCode = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == debugTextFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                debugText = castingValue.value(String.class);
+              }
+            }
+          }
+          callback.onSuccess(errorCode, debugText);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void readWiredAssessedInputFrequencyAttribute(long chipClusterPtr, WiredAssessedInputFrequencyAttributeCallback callback);
+    public void commissioningComplete(CommissioningCompleteResponseCallback callback) {
+      commissioningComplete(callback, 0);
+    }
 
-    private native void subscribeWiredAssessedInputFrequencyAttribute(long chipClusterPtr, WiredAssessedInputFrequencyAttributeCallback callback, int minInterval, int maxInterval);
+    public void commissioningComplete(CommissioningCompleteResponseCallback callback, int timedInvokeTimeoutMs) {
+      final long commandId = 4L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long errorCodeFieldID = 0L;
+          Integer errorCode = null;
+          final long debugTextFieldID = 1L;
+          String debugText = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == errorCodeFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                errorCode = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == debugTextFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                debugText = castingValue.value(String.class);
+              }
+            }
+          }
+          callback.onSuccess(errorCode, debugText);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface ArmFailSafeResponseCallback extends BaseClusterCallback {
+      void onSuccess(Integer errorCode, String debugText);
+    }
 
-    private native void readWiredCurrentTypeAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public interface SetRegulatoryConfigResponseCallback extends BaseClusterCallback {
+      void onSuccess(Integer errorCode, String debugText);
+    }
 
-    private native void subscribeWiredCurrentTypeAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public interface CommissioningCompleteResponseCallback extends BaseClusterCallback {
+      void onSuccess(Integer errorCode, String debugText);
+    }
 
-    private native void readWiredAssessedCurrentAttribute(long chipClusterPtr, WiredAssessedCurrentAttributeCallback callback);
+    public interface BasicCommissioningInfoAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(ChipStructs.GeneralCommissioningClusterBasicCommissioningInfo value);
+    }
 
-    private native void subscribeWiredAssessedCurrentAttribute(long chipClusterPtr, WiredAssessedCurrentAttributeCallback callback, int minInterval, int maxInterval);
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void readWiredNominalVoltageAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void subscribeWiredNominalVoltageAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void readWiredMaximumCurrentAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void subscribeWiredMaximumCurrentAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+    public void readBreadcrumbAttribute(
+        LongAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BREADCRUMB_ATTRIBUTE_ID);
 
-    private native void readWiredPresentAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BREADCRUMB_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeWiredPresentAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeBreadcrumbAttribute(DefaultClusterCallback callback, Long value) {
+      writeBreadcrumbAttribute(callback, value, 0);
+    }
 
-    private native void readActiveWiredFaultsAttribute(long chipClusterPtr, ActiveWiredFaultsAttributeCallback callback);
+    public void writeBreadcrumbAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), BREADCRUMB_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void subscribeActiveWiredFaultsAttribute(long chipClusterPtr, ActiveWiredFaultsAttributeCallback callback, int minInterval, int maxInterval);
+    public void subscribeBreadcrumbAttribute(
+        LongAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BREADCRUMB_ATTRIBUTE_ID);
 
-    private native void readBatVoltageAttribute(long chipClusterPtr, BatVoltageAttributeCallback callback);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BREADCRUMB_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void subscribeBatVoltageAttribute(long chipClusterPtr, BatVoltageAttributeCallback callback, int minInterval, int maxInterval);
+    public void readBasicCommissioningInfoAttribute(
+        BasicCommissioningInfoAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BASIC_COMMISSIONING_INFO_ATTRIBUTE_ID);
 
-    private native void readBatPercentRemainingAttribute(long chipClusterPtr, BatPercentRemainingAttributeCallback callback);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            ChipStructs.GeneralCommissioningClusterBasicCommissioningInfo value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BASIC_COMMISSIONING_INFO_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeBatPercentRemainingAttribute(long chipClusterPtr, BatPercentRemainingAttributeCallback callback, int minInterval, int maxInterval);
+    public void subscribeBasicCommissioningInfoAttribute(
+        BasicCommissioningInfoAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BASIC_COMMISSIONING_INFO_ATTRIBUTE_ID);
 
-    private native void readBatTimeRemainingAttribute(long chipClusterPtr, BatTimeRemainingAttributeCallback callback);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            ChipStructs.GeneralCommissioningClusterBasicCommissioningInfo value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BASIC_COMMISSIONING_INFO_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void subscribeBatTimeRemainingAttribute(long chipClusterPtr, BatTimeRemainingAttributeCallback callback, int minInterval, int maxInterval);
+    public void readRegulatoryConfigAttribute(
+        IntegerAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REGULATORY_CONFIG_ATTRIBUTE_ID);
 
-    private native void readBatChargeLevelAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeBatChargeLevelAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBatReplacementNeededAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
-
-    private native void subscribeBatReplacementNeededAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBatReplaceabilityAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeBatReplaceabilityAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBatPresentAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
-
-    private native void subscribeBatPresentAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readActiveBatFaultsAttribute(long chipClusterPtr, ActiveBatFaultsAttributeCallback callback);
-
-    private native void subscribeActiveBatFaultsAttribute(long chipClusterPtr, ActiveBatFaultsAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBatReplacementDescriptionAttribute(long chipClusterPtr, CharStringAttributeCallback callback);
-
-    private native void subscribeBatReplacementDescriptionAttribute(long chipClusterPtr, CharStringAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBatCommonDesignationAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeBatCommonDesignationAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBatANSIDesignationAttribute(long chipClusterPtr, CharStringAttributeCallback callback);
-
-    private native void subscribeBatANSIDesignationAttribute(long chipClusterPtr, CharStringAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBatIECDesignationAttribute(long chipClusterPtr, CharStringAttributeCallback callback);
-
-    private native void subscribeBatIECDesignationAttribute(long chipClusterPtr, CharStringAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBatApprovedChemistryAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeBatApprovedChemistryAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBatCapacityAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeBatCapacityAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBatQuantityAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeBatQuantityAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBatChargeStateAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeBatChargeStateAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBatTimeToFullChargeAttribute(long chipClusterPtr, BatTimeToFullChargeAttributeCallback callback);
-
-    private native void subscribeBatTimeToFullChargeAttribute(long chipClusterPtr, BatTimeToFullChargeAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBatFunctionalWhileChargingAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
-
-    private native void subscribeBatFunctionalWhileChargingAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBatChargingCurrentAttribute(long chipClusterPtr, BatChargingCurrentAttributeCallback callback);
-
-    private native void subscribeBatChargingCurrentAttribute(long chipClusterPtr, BatChargingCurrentAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readActiveBatChargeFaultsAttribute(long chipClusterPtr, ActiveBatChargeFaultsAttributeCallback callback);
-
-    private native void subscribeActiveBatChargeFaultsAttribute(long chipClusterPtr, ActiveBatChargeFaultsAttributeCallback 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 readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-  }
-
-  public static class GeneralCommissioningCluster extends BaseChipCluster {
-    public static final long CLUSTER_ID = 48L;
-
-    public GeneralCommissioningCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
-    }
-
-    @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
-
-    public void armFailSafe(ArmFailSafeResponseCallback callback, Integer expiryLengthSeconds, Long breadcrumb) {
-      armFailSafe(chipClusterPtr, callback, expiryLengthSeconds, breadcrumb, null);
-    }
-
-    public void armFailSafe(ArmFailSafeResponseCallback callback, Integer expiryLengthSeconds, Long breadcrumb, int timedInvokeTimeoutMs) {
-      armFailSafe(chipClusterPtr, callback, expiryLengthSeconds, breadcrumb, timedInvokeTimeoutMs);
-    }
-
-    public void setRegulatoryConfig(SetRegulatoryConfigResponseCallback callback, Integer newRegulatoryConfig, String countryCode, Long breadcrumb) {
-      setRegulatoryConfig(chipClusterPtr, callback, newRegulatoryConfig, countryCode, breadcrumb, null);
-    }
-
-    public void setRegulatoryConfig(SetRegulatoryConfigResponseCallback callback, Integer newRegulatoryConfig, String countryCode, Long breadcrumb, int timedInvokeTimeoutMs) {
-      setRegulatoryConfig(chipClusterPtr, callback, newRegulatoryConfig, countryCode, breadcrumb, timedInvokeTimeoutMs);
-    }
-
-    public void commissioningComplete(CommissioningCompleteResponseCallback callback) {
-      commissioningComplete(chipClusterPtr, callback, null);
-    }
-
-    public void commissioningComplete(CommissioningCompleteResponseCallback callback, int timedInvokeTimeoutMs) {
-      commissioningComplete(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
-
-    private native void armFailSafe(long chipClusterPtr, ArmFailSafeResponseCallback callback, Integer expiryLengthSeconds, Long breadcrumb, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void setRegulatoryConfig(long chipClusterPtr, SetRegulatoryConfigResponseCallback callback, Integer newRegulatoryConfig, String countryCode, Long breadcrumb, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void commissioningComplete(long chipClusterPtr, CommissioningCompleteResponseCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    public interface ArmFailSafeResponseCallback {
-      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 CommissioningCompleteResponseCallback {
-      void onSuccess(Integer errorCode, String debugText);
-      void onError(Exception error);
-    }
-
-    public interface BasicCommissioningInfoAttributeCallback {
-      void onSuccess(ChipStructs.GeneralCommissioningClusterBasicCommissioningInfo value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface GeneratedCommandListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface AcceptedCommandListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface EventListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface AttributeListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    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) {
-        writeBreadcrumbAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
-
-    public void subscribeBreadcrumbAttribute(
-        LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBreadcrumbAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    public void readBasicCommissioningInfoAttribute(
-        BasicCommissioningInfoAttributeCallback callback) {
-        readBasicCommissioningInfoAttribute(chipClusterPtr, callback);
-    }
-
-    public void subscribeBasicCommissioningInfoAttribute(
-        BasicCommissioningInfoAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBasicCommissioningInfoAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    public void readRegulatoryConfigAttribute(
-        IntegerAttributeCallback callback) {
-        readRegulatoryConfigAttribute(chipClusterPtr, callback);
-    }
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, REGULATORY_CONFIG_ATTRIBUTE_ID, true);
+    }
 
     public void subscribeRegulatoryConfigAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRegulatoryConfigAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REGULATORY_CONFIG_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, REGULATORY_CONFIG_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLocationCapabilityAttribute(
         IntegerAttributeCallback callback) {
-        readLocationCapabilityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOCATION_CAPABILITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LOCATION_CAPABILITY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLocationCapabilityAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLocationCapabilityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOCATION_CAPABILITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LOCATION_CAPABILITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSupportsConcurrentConnectionAttribute(
         BooleanAttributeCallback callback) {
-        readSupportsConcurrentConnectionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTS_CONCURRENT_CONNECTION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SUPPORTS_CONCURRENT_CONNECTION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSupportsConcurrentConnectionAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSupportsConcurrentConnectionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTS_CONCURRENT_CONNECTION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SUPPORTS_CONCURRENT_CONNECTION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readBasicCommissioningInfoAttribute(long chipClusterPtr, BasicCommissioningInfoAttributeCallback callback);
-
-    private native void subscribeBasicCommissioningInfoAttribute(long chipClusterPtr, BasicCommissioningInfoAttributeCallback 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 readSupportsConcurrentConnectionAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
-
-    private native void subscribeSupportsConcurrentConnectionAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class NetworkCommissioningCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 49L;
 
+    private static final long MAX_NETWORKS_ATTRIBUTE_ID = 0L;
+    private static final long NETWORKS_ATTRIBUTE_ID = 1L;
+    private static final long SCAN_MAX_TIME_SECONDS_ATTRIBUTE_ID = 2L;
+    private static final long CONNECT_MAX_TIME_SECONDS_ATTRIBUTE_ID = 3L;
+    private static final long INTERFACE_ENABLED_ATTRIBUTE_ID = 4L;
+    private static final long LAST_NETWORKING_STATUS_ATTRIBUTE_ID = 5L;
+    private static final long LAST_NETWORK_I_D_ATTRIBUTE_ID = 6L;
+    private static final long LAST_CONNECT_ERROR_VALUE_ATTRIBUTE_ID = 7L;
+    private static final long SUPPORTED_WI_FI_BANDS_ATTRIBUTE_ID = 8L;
+    private static final long SUPPORTED_THREAD_FEATURES_ATTRIBUTE_ID = 9L;
+    private static final long THREAD_VERSION_ATTRIBUTE_ID = 10L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public NetworkCommissioningCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void scanNetworks(ScanNetworksResponseCallback callback, @Nullable Optional<byte[]> ssid, Optional<Long> breadcrumb) {
-      scanNetworks(chipClusterPtr, callback, ssid, breadcrumb, null);
+      scanNetworks(callback, ssid, breadcrumb, 0);
     }
 
     public void scanNetworks(ScanNetworksResponseCallback callback, @Nullable Optional<byte[]> ssid, Optional<Long> breadcrumb, int timedInvokeTimeoutMs) {
-      scanNetworks(chipClusterPtr, callback, ssid, breadcrumb, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long ssidFieldID = 0L;
+      BaseTLVType ssidtlvValue = ssid != null ? ssid.<BaseTLVType>map((nonOptionalssid) -> new ByteArrayType(nonOptionalssid)).orElse(new EmptyType()) : new NullType();
+      elements.add(new StructElement(ssidFieldID, ssidtlvValue));
+
+      final long breadcrumbFieldID = 1L;
+      BaseTLVType breadcrumbtlvValue = breadcrumb.<BaseTLVType>map((nonOptionalbreadcrumb) -> new UIntType(nonOptionalbreadcrumb)).orElse(new EmptyType());
+      elements.add(new StructElement(breadcrumbFieldID, breadcrumbtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long networkingStatusFieldID = 0L;
+          Integer networkingStatus = null;
+          final long debugTextFieldID = 1L;
+          Optional<String> debugText = Optional.empty();
+          final long wiFiScanResultsFieldID = 2L;
+          Optional<ArrayList<ChipStructs.NetworkCommissioningClusterWiFiInterfaceScanResultStruct>> wiFiScanResults = Optional.empty();
+          final long threadScanResultsFieldID = 3L;
+          Optional<ArrayList<ChipStructs.NetworkCommissioningClusterThreadInterfaceScanResultStruct>> threadScanResults = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == networkingStatusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                networkingStatus = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == debugTextFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                debugText = Optional.of(castingValue.value(String.class));
+              }
+            } else if (element.contextTagNum() == wiFiScanResultsFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+                ArrayType castingValue = element.value(ArrayType.class);
+                wiFiScanResults = Optional.of(castingValue.map((elementcastingValue) -> ChipStructs.NetworkCommissioningClusterWiFiInterfaceScanResultStruct.decodeTlv(elementcastingValue)));
+              }
+            } else if (element.contextTagNum() == threadScanResultsFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+                ArrayType castingValue = element.value(ArrayType.class);
+                threadScanResults = Optional.of(castingValue.map((elementcastingValue) -> ChipStructs.NetworkCommissioningClusterThreadInterfaceScanResultStruct.decodeTlv(elementcastingValue)));
+              }
+            }
+          }
+          callback.onSuccess(networkingStatus, debugText, wiFiScanResults, threadScanResults);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void addOrUpdateWiFiNetwork(NetworkConfigResponseCallback callback, byte[] ssid, byte[] credentials, Optional<Long> breadcrumb) {
-      addOrUpdateWiFiNetwork(chipClusterPtr, callback, ssid, credentials, breadcrumb, null);
+      addOrUpdateWiFiNetwork(callback, ssid, credentials, breadcrumb, 0);
     }
 
     public void addOrUpdateWiFiNetwork(NetworkConfigResponseCallback callback, byte[] ssid, byte[] credentials, Optional<Long> breadcrumb, int timedInvokeTimeoutMs) {
-      addOrUpdateWiFiNetwork(chipClusterPtr, callback, ssid, credentials, breadcrumb, timedInvokeTimeoutMs);
+      final long commandId = 2L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long ssidFieldID = 0L;
+      BaseTLVType ssidtlvValue = new ByteArrayType(ssid);
+      elements.add(new StructElement(ssidFieldID, ssidtlvValue));
+
+      final long credentialsFieldID = 1L;
+      BaseTLVType credentialstlvValue = new ByteArrayType(credentials);
+      elements.add(new StructElement(credentialsFieldID, credentialstlvValue));
+
+      final long breadcrumbFieldID = 2L;
+      BaseTLVType breadcrumbtlvValue = breadcrumb.<BaseTLVType>map((nonOptionalbreadcrumb) -> new UIntType(nonOptionalbreadcrumb)).orElse(new EmptyType());
+      elements.add(new StructElement(breadcrumbFieldID, breadcrumbtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long networkingStatusFieldID = 0L;
+          Integer networkingStatus = null;
+          final long debugTextFieldID = 1L;
+          Optional<String> debugText = Optional.empty();
+          final long networkIndexFieldID = 2L;
+          Optional<Integer> networkIndex = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == networkingStatusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                networkingStatus = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == debugTextFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                debugText = Optional.of(castingValue.value(String.class));
+              }
+            } else if (element.contextTagNum() == networkIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                networkIndex = Optional.of(castingValue.value(Integer.class));
+              }
+            }
+          }
+          callback.onSuccess(networkingStatus, debugText, networkIndex);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void addOrUpdateThreadNetwork(NetworkConfigResponseCallback callback, byte[] operationalDataset, Optional<Long> breadcrumb) {
-      addOrUpdateThreadNetwork(chipClusterPtr, callback, operationalDataset, breadcrumb, null);
+      addOrUpdateThreadNetwork(callback, operationalDataset, breadcrumb, 0);
     }
 
     public void addOrUpdateThreadNetwork(NetworkConfigResponseCallback callback, byte[] operationalDataset, Optional<Long> breadcrumb, int timedInvokeTimeoutMs) {
-      addOrUpdateThreadNetwork(chipClusterPtr, callback, operationalDataset, breadcrumb, timedInvokeTimeoutMs);
+      final long commandId = 3L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long operationalDatasetFieldID = 0L;
+      BaseTLVType operationalDatasettlvValue = new ByteArrayType(operationalDataset);
+      elements.add(new StructElement(operationalDatasetFieldID, operationalDatasettlvValue));
+
+      final long breadcrumbFieldID = 1L;
+      BaseTLVType breadcrumbtlvValue = breadcrumb.<BaseTLVType>map((nonOptionalbreadcrumb) -> new UIntType(nonOptionalbreadcrumb)).orElse(new EmptyType());
+      elements.add(new StructElement(breadcrumbFieldID, breadcrumbtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long networkingStatusFieldID = 0L;
+          Integer networkingStatus = null;
+          final long debugTextFieldID = 1L;
+          Optional<String> debugText = Optional.empty();
+          final long networkIndexFieldID = 2L;
+          Optional<Integer> networkIndex = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == networkingStatusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                networkingStatus = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == debugTextFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                debugText = Optional.of(castingValue.value(String.class));
+              }
+            } else if (element.contextTagNum() == networkIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                networkIndex = Optional.of(castingValue.value(Integer.class));
+              }
+            }
+          }
+          callback.onSuccess(networkingStatus, debugText, networkIndex);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void removeNetwork(NetworkConfigResponseCallback callback, byte[] networkID, Optional<Long> breadcrumb) {
-      removeNetwork(chipClusterPtr, callback, networkID, breadcrumb, null);
+      removeNetwork(callback, networkID, breadcrumb, 0);
     }
 
     public void removeNetwork(NetworkConfigResponseCallback callback, byte[] networkID, Optional<Long> breadcrumb, int timedInvokeTimeoutMs) {
-      removeNetwork(chipClusterPtr, callback, networkID, breadcrumb, timedInvokeTimeoutMs);
+      final long commandId = 4L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long networkIDFieldID = 0L;
+      BaseTLVType networkIDtlvValue = new ByteArrayType(networkID);
+      elements.add(new StructElement(networkIDFieldID, networkIDtlvValue));
+
+      final long breadcrumbFieldID = 1L;
+      BaseTLVType breadcrumbtlvValue = breadcrumb.<BaseTLVType>map((nonOptionalbreadcrumb) -> new UIntType(nonOptionalbreadcrumb)).orElse(new EmptyType());
+      elements.add(new StructElement(breadcrumbFieldID, breadcrumbtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long networkingStatusFieldID = 0L;
+          Integer networkingStatus = null;
+          final long debugTextFieldID = 1L;
+          Optional<String> debugText = Optional.empty();
+          final long networkIndexFieldID = 2L;
+          Optional<Integer> networkIndex = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == networkingStatusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                networkingStatus = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == debugTextFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                debugText = Optional.of(castingValue.value(String.class));
+              }
+            } else if (element.contextTagNum() == networkIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                networkIndex = Optional.of(castingValue.value(Integer.class));
+              }
+            }
+          }
+          callback.onSuccess(networkingStatus, debugText, networkIndex);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void connectNetwork(ConnectNetworkResponseCallback callback, byte[] networkID, Optional<Long> breadcrumb) {
-      connectNetwork(chipClusterPtr, callback, networkID, breadcrumb, null);
+      connectNetwork(callback, networkID, breadcrumb, 0);
     }
 
     public void connectNetwork(ConnectNetworkResponseCallback callback, byte[] networkID, Optional<Long> breadcrumb, int timedInvokeTimeoutMs) {
-      connectNetwork(chipClusterPtr, callback, networkID, breadcrumb, timedInvokeTimeoutMs);
+      final long commandId = 6L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long networkIDFieldID = 0L;
+      BaseTLVType networkIDtlvValue = new ByteArrayType(networkID);
+      elements.add(new StructElement(networkIDFieldID, networkIDtlvValue));
+
+      final long breadcrumbFieldID = 1L;
+      BaseTLVType breadcrumbtlvValue = breadcrumb.<BaseTLVType>map((nonOptionalbreadcrumb) -> new UIntType(nonOptionalbreadcrumb)).orElse(new EmptyType());
+      elements.add(new StructElement(breadcrumbFieldID, breadcrumbtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long networkingStatusFieldID = 0L;
+          Integer networkingStatus = null;
+          final long debugTextFieldID = 1L;
+          Optional<String> debugText = Optional.empty();
+          final long errorValueFieldID = 2L;
+          @Nullable Long errorValue = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == networkingStatusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                networkingStatus = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == debugTextFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                debugText = Optional.of(castingValue.value(String.class));
+              }
+            } else if (element.contextTagNum() == errorValueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Int) {
+                IntType castingValue = element.value(IntType.class);
+                errorValue = castingValue.value(Long.class);
+              }
+            }
+          }
+          callback.onSuccess(networkingStatus, debugText, errorValue);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void reorderNetwork(NetworkConfigResponseCallback callback, byte[] networkID, Integer networkIndex, Optional<Long> breadcrumb) {
-      reorderNetwork(chipClusterPtr, callback, networkID, networkIndex, breadcrumb, null);
+      reorderNetwork(callback, networkID, networkIndex, breadcrumb, 0);
     }
 
     public void reorderNetwork(NetworkConfigResponseCallback callback, byte[] networkID, Integer networkIndex, Optional<Long> breadcrumb, int timedInvokeTimeoutMs) {
-      reorderNetwork(chipClusterPtr, callback, networkID, networkIndex, breadcrumb, timedInvokeTimeoutMs);
-    }
-
-    private native void scanNetworks(long chipClusterPtr, ScanNetworksResponseCallback callback, @Nullable Optional<byte[]> ssid, Optional<Long> breadcrumb, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void addOrUpdateWiFiNetwork(long chipClusterPtr, NetworkConfigResponseCallback callback, byte[] ssid, byte[] credentials, Optional<Long> breadcrumb, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void addOrUpdateThreadNetwork(long chipClusterPtr, NetworkConfigResponseCallback callback, byte[] operationalDataset, Optional<Long> breadcrumb, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void removeNetwork(long chipClusterPtr, NetworkConfigResponseCallback callback, byte[] networkID, Optional<Long> breadcrumb, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void connectNetwork(long chipClusterPtr, ConnectNetworkResponseCallback callback, byte[] networkID, Optional<Long> breadcrumb, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void reorderNetwork(long chipClusterPtr, NetworkConfigResponseCallback callback, byte[] networkID, Integer networkIndex, Optional<Long> breadcrumb, @Nullable Integer timedInvokeTimeoutMs);
-
-    public interface ScanNetworksResponseCallback {
+      final long commandId = 8L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long networkIDFieldID = 0L;
+      BaseTLVType networkIDtlvValue = new ByteArrayType(networkID);
+      elements.add(new StructElement(networkIDFieldID, networkIDtlvValue));
+
+      final long networkIndexFieldID = 1L;
+      BaseTLVType networkIndextlvValue = new UIntType(networkIndex);
+      elements.add(new StructElement(networkIndexFieldID, networkIndextlvValue));
+
+      final long breadcrumbFieldID = 2L;
+      BaseTLVType breadcrumbtlvValue = breadcrumb.<BaseTLVType>map((nonOptionalbreadcrumb) -> new UIntType(nonOptionalbreadcrumb)).orElse(new EmptyType());
+      elements.add(new StructElement(breadcrumbFieldID, breadcrumbtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long networkingStatusFieldID = 0L;
+          Integer networkingStatus = null;
+          final long debugTextFieldID = 1L;
+          Optional<String> debugText = Optional.empty();
+          final long networkIndexFieldID = 2L;
+          Optional<Integer> networkIndex = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == networkingStatusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                networkingStatus = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == debugTextFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                debugText = Optional.of(castingValue.value(String.class));
+              }
+            } else if (element.contextTagNum() == networkIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                networkIndex = Optional.of(castingValue.value(Integer.class));
+              }
+            }
+          }
+          callback.onSuccess(networkingStatus, debugText, networkIndex);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface ScanNetworksResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer networkingStatus, Optional<String> debugText, Optional<ArrayList<ChipStructs.NetworkCommissioningClusterWiFiInterfaceScanResultStruct>> wiFiScanResults, Optional<ArrayList<ChipStructs.NetworkCommissioningClusterThreadInterfaceScanResultStruct>> threadScanResults);
-      void onError(Exception error);
     }
 
-    public interface NetworkConfigResponseCallback {
+    public interface NetworkConfigResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer networkingStatus, Optional<String> debugText, Optional<Integer> networkIndex);
-      void onError(Exception error);
     }
 
-    public interface ConnectNetworkResponseCallback {
+    public interface ConnectNetworkResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer networkingStatus, Optional<String> debugText, @Nullable Long errorValue);
-      void onError(Exception error);
     }
 
-    public interface NetworksAttributeCallback {
+    public interface NetworksAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.NetworkCommissioningClusterNetworkInfoStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface LastNetworkingStatusAttributeCallback {
+    public interface LastNetworkingStatusAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface LastNetworkIDAttributeCallback {
+    public interface LastNetworkIDAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable byte[] value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface LastConnectErrorValueAttributeCallback {
+    public interface LastConnectErrorValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface SupportedWiFiBandsAttributeCallback {
+    public interface SupportedWiFiBandsAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Integer> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readMaxNetworksAttribute(
         IntegerAttributeCallback callback) {
-        readMaxNetworksAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_NETWORKS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_NETWORKS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxNetworksAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxNetworksAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_NETWORKS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_NETWORKS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readNetworksAttribute(
         NetworksAttributeCallback callback) {
-        readNetworksAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NETWORKS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.NetworkCommissioningClusterNetworkInfoStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NETWORKS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeNetworksAttribute(
         NetworksAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNetworksAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NETWORKS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.NetworkCommissioningClusterNetworkInfoStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NETWORKS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readScanMaxTimeSecondsAttribute(
         IntegerAttributeCallback callback) {
-        readScanMaxTimeSecondsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SCAN_MAX_TIME_SECONDS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SCAN_MAX_TIME_SECONDS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeScanMaxTimeSecondsAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeScanMaxTimeSecondsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SCAN_MAX_TIME_SECONDS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SCAN_MAX_TIME_SECONDS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readConnectMaxTimeSecondsAttribute(
         IntegerAttributeCallback callback) {
-        readConnectMaxTimeSecondsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CONNECT_MAX_TIME_SECONDS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CONNECT_MAX_TIME_SECONDS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeConnectMaxTimeSecondsAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeConnectMaxTimeSecondsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CONNECT_MAX_TIME_SECONDS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CONNECT_MAX_TIME_SECONDS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readInterfaceEnabledAttribute(
         BooleanAttributeCallback callback) {
-        readInterfaceEnabledAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INTERFACE_ENABLED_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INTERFACE_ENABLED_ATTRIBUTE_ID, true);
     }
 
     public void writeInterfaceEnabledAttribute(DefaultClusterCallback callback, Boolean value) {
-        writeInterfaceEnabledAttribute(chipClusterPtr, callback, value, null);
+      writeInterfaceEnabledAttribute(callback, value, 0);
     }
 
     public void writeInterfaceEnabledAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
-        writeInterfaceEnabledAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new BooleanType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), INTERFACE_ENABLED_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeInterfaceEnabledAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInterfaceEnabledAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INTERFACE_ENABLED_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INTERFACE_ENABLED_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLastNetworkingStatusAttribute(
         LastNetworkingStatusAttributeCallback callback) {
-        readLastNetworkingStatusAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAST_NETWORKING_STATUS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LAST_NETWORKING_STATUS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLastNetworkingStatusAttribute(
         LastNetworkingStatusAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLastNetworkingStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAST_NETWORKING_STATUS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LAST_NETWORKING_STATUS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLastNetworkIDAttribute(
         LastNetworkIDAttributeCallback callback) {
-        readLastNetworkIDAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAST_NETWORK_I_D_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable byte[] value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LAST_NETWORK_I_D_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLastNetworkIDAttribute(
         LastNetworkIDAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLastNetworkIDAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAST_NETWORK_I_D_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable byte[] value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LAST_NETWORK_I_D_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLastConnectErrorValueAttribute(
         LastConnectErrorValueAttributeCallback callback) {
-        readLastConnectErrorValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAST_CONNECT_ERROR_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LAST_CONNECT_ERROR_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLastConnectErrorValueAttribute(
         LastConnectErrorValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLastConnectErrorValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAST_CONNECT_ERROR_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LAST_CONNECT_ERROR_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSupportedWiFiBandsAttribute(
         SupportedWiFiBandsAttributeCallback callback) {
-        readSupportedWiFiBandsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_WI_FI_BANDS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SUPPORTED_WI_FI_BANDS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSupportedWiFiBandsAttribute(
         SupportedWiFiBandsAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSupportedWiFiBandsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_WI_FI_BANDS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SUPPORTED_WI_FI_BANDS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSupportedThreadFeaturesAttribute(
         IntegerAttributeCallback callback) {
-        readSupportedThreadFeaturesAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_THREAD_FEATURES_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SUPPORTED_THREAD_FEATURES_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSupportedThreadFeaturesAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSupportedThreadFeaturesAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_THREAD_FEATURES_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SUPPORTED_THREAD_FEATURES_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readThreadVersionAttribute(
         IntegerAttributeCallback callback) {
-        readThreadVersionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, THREAD_VERSION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, THREAD_VERSION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeThreadVersionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeThreadVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, THREAD_VERSION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, THREAD_VERSION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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, LastNetworkingStatusAttributeCallback callback);
-
-    private native void subscribeLastNetworkingStatusAttribute(long chipClusterPtr, LastNetworkingStatusAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readLastNetworkIDAttribute(long chipClusterPtr, LastNetworkIDAttributeCallback callback);
-
-    private native void subscribeLastNetworkIDAttribute(long chipClusterPtr, LastNetworkIDAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLastConnectErrorValueAttribute(long chipClusterPtr, LastConnectErrorValueAttributeCallback callback);
-
-    private native void subscribeLastConnectErrorValueAttribute(long chipClusterPtr, LastConnectErrorValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSupportedWiFiBandsAttribute(long chipClusterPtr, SupportedWiFiBandsAttributeCallback callback);
-
-    private native void subscribeSupportedWiFiBandsAttribute(long chipClusterPtr, SupportedWiFiBandsAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSupportedThreadFeaturesAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeSupportedThreadFeaturesAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readThreadVersionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeThreadVersionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class DiagnosticLogsCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 50L;
 
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public DiagnosticLogsCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void retrieveLogsRequest(RetrieveLogsResponseCallback callback, Integer intent, Integer requestedProtocol, Optional<String> transferFileDesignator) {
-      retrieveLogsRequest(chipClusterPtr, callback, intent, requestedProtocol, transferFileDesignator, null);
+      retrieveLogsRequest(callback, intent, requestedProtocol, transferFileDesignator, 0);
     }
 
     public void retrieveLogsRequest(RetrieveLogsResponseCallback callback, Integer intent, Integer requestedProtocol, Optional<String> transferFileDesignator, int timedInvokeTimeoutMs) {
-      retrieveLogsRequest(chipClusterPtr, callback, intent, requestedProtocol, transferFileDesignator, timedInvokeTimeoutMs);
-    }
-
-    private native void retrieveLogsRequest(long chipClusterPtr, RetrieveLogsResponseCallback callback, Integer intent, Integer requestedProtocol, Optional<String> transferFileDesignator, @Nullable Integer timedInvokeTimeoutMs);
-
-    public interface RetrieveLogsResponseCallback {
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long intentFieldID = 0L;
+      BaseTLVType intenttlvValue = new UIntType(intent);
+      elements.add(new StructElement(intentFieldID, intenttlvValue));
+
+      final long requestedProtocolFieldID = 1L;
+      BaseTLVType requestedProtocoltlvValue = new UIntType(requestedProtocol);
+      elements.add(new StructElement(requestedProtocolFieldID, requestedProtocoltlvValue));
+
+      final long transferFileDesignatorFieldID = 2L;
+      BaseTLVType transferFileDesignatortlvValue = transferFileDesignator.<BaseTLVType>map((nonOptionaltransferFileDesignator) -> new StringType(nonOptionaltransferFileDesignator)).orElse(new EmptyType());
+      elements.add(new StructElement(transferFileDesignatorFieldID, transferFileDesignatortlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long logContentFieldID = 1L;
+          byte[] logContent = null;
+          final long UTCTimeStampFieldID = 2L;
+          Optional<Long> UTCTimeStamp = Optional.empty();
+          final long timeSinceBootFieldID = 3L;
+          Optional<Long> timeSinceBoot = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == logContentFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+                ByteArrayType castingValue = element.value(ByteArrayType.class);
+                logContent = castingValue.value(byte[].class);
+              }
+            } else if (element.contextTagNum() == UTCTimeStampFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                UTCTimeStamp = Optional.of(castingValue.value(Long.class));
+              }
+            } else if (element.contextTagNum() == timeSinceBootFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                timeSinceBoot = Optional.of(castingValue.value(Long.class));
+              }
+            }
+          }
+          callback.onSuccess(status, logContent, UTCTimeStamp, timeSinceBoot);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface RetrieveLogsResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, byte[] logContent, Optional<Long> UTCTimeStamp, Optional<Long> timeSinceBoot);
-      void onError(Exception error);
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    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);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class GeneralDiagnosticsCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 51L;
 
+    private static final long NETWORK_INTERFACES_ATTRIBUTE_ID = 0L;
+    private static final long REBOOT_COUNT_ATTRIBUTE_ID = 1L;
+    private static final long UP_TIME_ATTRIBUTE_ID = 2L;
+    private static final long TOTAL_OPERATIONAL_HOURS_ATTRIBUTE_ID = 3L;
+    private static final long BOOT_REASON_ATTRIBUTE_ID = 4L;
+    private static final long ACTIVE_HARDWARE_FAULTS_ATTRIBUTE_ID = 5L;
+    private static final long ACTIVE_RADIO_FAULTS_ATTRIBUTE_ID = 6L;
+    private static final long ACTIVE_NETWORK_FAULTS_ATTRIBUTE_ID = 7L;
+    private static final long TEST_EVENT_TRIGGERS_ENABLED_ATTRIBUTE_ID = 8L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public GeneralDiagnosticsCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void testEventTrigger(DefaultClusterCallback callback, byte[] enableKey, Long eventTrigger) {
-      testEventTrigger(chipClusterPtr, callback, enableKey, eventTrigger, null);
+      testEventTrigger(callback, enableKey, eventTrigger, 0);
     }
 
     public void testEventTrigger(DefaultClusterCallback callback, byte[] enableKey, Long eventTrigger, int timedInvokeTimeoutMs) {
-      testEventTrigger(chipClusterPtr, callback, enableKey, eventTrigger, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long enableKeyFieldID = 0L;
+      BaseTLVType enableKeytlvValue = new ByteArrayType(enableKey);
+      elements.add(new StructElement(enableKeyFieldID, enableKeytlvValue));
+
+      final long eventTriggerFieldID = 1L;
+      BaseTLVType eventTriggertlvValue = new UIntType(eventTrigger);
+      elements.add(new StructElement(eventTriggerFieldID, eventTriggertlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void timeSnapshot(TimeSnapshotResponseCallback callback) {
-      timeSnapshot(chipClusterPtr, callback, null);
+      timeSnapshot(callback, 0);
     }
 
     public void timeSnapshot(TimeSnapshotResponseCallback callback, int timedInvokeTimeoutMs) {
-      timeSnapshot(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
-
-    private native void testEventTrigger(long chipClusterPtr, DefaultClusterCallback callback, byte[] enableKey, Long eventTrigger, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void timeSnapshot(long chipClusterPtr, TimeSnapshotResponseCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    public interface TimeSnapshotResponseCallback {
+      final long commandId = 1L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long systemTimeUsFieldID = 0L;
+          Long systemTimeUs = null;
+          final long UTCTimeUsFieldID = 1L;
+          @Nullable Long UTCTimeUs = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == systemTimeUsFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                systemTimeUs = castingValue.value(Long.class);
+              }
+            } else if (element.contextTagNum() == UTCTimeUsFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                UTCTimeUs = castingValue.value(Long.class);
+              }
+            }
+          }
+          callback.onSuccess(systemTimeUs, UTCTimeUs);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface TimeSnapshotResponseCallback extends BaseClusterCallback {
       void onSuccess(Long systemTimeUs, @Nullable Long UTCTimeUs);
-      void onError(Exception error);
     }
 
-    public interface NetworkInterfacesAttributeCallback {
+    public interface NetworkInterfacesAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.GeneralDiagnosticsClusterNetworkInterface> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ActiveHardwareFaultsAttributeCallback {
+    public interface ActiveHardwareFaultsAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Integer> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ActiveRadioFaultsAttributeCallback {
+    public interface ActiveRadioFaultsAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Integer> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ActiveNetworkFaultsAttributeCallback {
+    public interface ActiveNetworkFaultsAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Integer> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readNetworkInterfacesAttribute(
         NetworkInterfacesAttributeCallback callback) {
-        readNetworkInterfacesAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NETWORK_INTERFACES_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.GeneralDiagnosticsClusterNetworkInterface> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NETWORK_INTERFACES_ATTRIBUTE_ID, true);
     }
 
     public void subscribeNetworkInterfacesAttribute(
         NetworkInterfacesAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNetworkInterfacesAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NETWORK_INTERFACES_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.GeneralDiagnosticsClusterNetworkInterface> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NETWORK_INTERFACES_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRebootCountAttribute(
         IntegerAttributeCallback callback) {
-        readRebootCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REBOOT_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, REBOOT_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRebootCountAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRebootCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REBOOT_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, REBOOT_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUpTimeAttribute(
         LongAttributeCallback callback) {
-        readUpTimeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UP_TIME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UP_TIME_ATTRIBUTE_ID, true);
     }
 
     public void subscribeUpTimeAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUpTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UP_TIME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UP_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTotalOperationalHoursAttribute(
         LongAttributeCallback callback) {
-        readTotalOperationalHoursAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TOTAL_OPERATIONAL_HOURS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TOTAL_OPERATIONAL_HOURS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTotalOperationalHoursAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTotalOperationalHoursAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TOTAL_OPERATIONAL_HOURS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TOTAL_OPERATIONAL_HOURS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBootReasonAttribute(
         IntegerAttributeCallback callback) {
-        readBootReasonAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BOOT_REASON_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BOOT_REASON_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBootReasonAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBootReasonAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BOOT_REASON_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BOOT_REASON_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActiveHardwareFaultsAttribute(
         ActiveHardwareFaultsAttributeCallback callback) {
-        readActiveHardwareFaultsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_HARDWARE_FAULTS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_HARDWARE_FAULTS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActiveHardwareFaultsAttribute(
         ActiveHardwareFaultsAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActiveHardwareFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_HARDWARE_FAULTS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_HARDWARE_FAULTS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActiveRadioFaultsAttribute(
         ActiveRadioFaultsAttributeCallback callback) {
-        readActiveRadioFaultsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_RADIO_FAULTS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_RADIO_FAULTS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActiveRadioFaultsAttribute(
         ActiveRadioFaultsAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActiveRadioFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_RADIO_FAULTS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_RADIO_FAULTS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActiveNetworkFaultsAttribute(
         ActiveNetworkFaultsAttributeCallback callback) {
-        readActiveNetworkFaultsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_NETWORK_FAULTS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_NETWORK_FAULTS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActiveNetworkFaultsAttribute(
         ActiveNetworkFaultsAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActiveNetworkFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_NETWORK_FAULTS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_NETWORK_FAULTS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTestEventTriggersEnabledAttribute(
         BooleanAttributeCallback callback) {
-        readTestEventTriggersEnabledAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TEST_EVENT_TRIGGERS_ENABLED_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TEST_EVENT_TRIGGERS_ENABLED_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTestEventTriggersEnabledAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTestEventTriggersEnabledAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TEST_EVENT_TRIGGERS_ENABLED_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TEST_EVENT_TRIGGERS_ENABLED_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readTotalOperationalHoursAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeTotalOperationalHoursAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBootReasonAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeBootReasonAttribute(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 readTestEventTriggersEnabledAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
-
-    private native void subscribeTestEventTriggersEnabledAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class SoftwareDiagnosticsCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 52L;
 
+    private static final long THREAD_METRICS_ATTRIBUTE_ID = 0L;
+    private static final long CURRENT_HEAP_FREE_ATTRIBUTE_ID = 1L;
+    private static final long CURRENT_HEAP_USED_ATTRIBUTE_ID = 2L;
+    private static final long CURRENT_HEAP_HIGH_WATERMARK_ATTRIBUTE_ID = 3L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public SoftwareDiagnosticsCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void resetWatermarks(DefaultClusterCallback callback) {
-      resetWatermarks(chipClusterPtr, callback, null);
+      resetWatermarks(callback, 0);
     }
 
     public void resetWatermarks(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      resetWatermarks(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
+      final long commandId = 0L;
 
-    private native void resetWatermarks(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface ThreadMetricsAttributeCallback {
+    public interface ThreadMetricsAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.SoftwareDiagnosticsClusterThreadMetricsStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readThreadMetricsAttribute(
         ThreadMetricsAttributeCallback callback) {
-        readThreadMetricsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, THREAD_METRICS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.SoftwareDiagnosticsClusterThreadMetricsStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, THREAD_METRICS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeThreadMetricsAttribute(
         ThreadMetricsAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeThreadMetricsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, THREAD_METRICS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.SoftwareDiagnosticsClusterThreadMetricsStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, THREAD_METRICS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentHeapFreeAttribute(
         LongAttributeCallback callback) {
-        readCurrentHeapFreeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_HEAP_FREE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_HEAP_FREE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentHeapFreeAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentHeapFreeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_HEAP_FREE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_HEAP_FREE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentHeapUsedAttribute(
         LongAttributeCallback callback) {
-        readCurrentHeapUsedAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_HEAP_USED_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_HEAP_USED_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentHeapUsedAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentHeapUsedAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_HEAP_USED_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_HEAP_USED_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentHeapHighWatermarkAttribute(
         LongAttributeCallback callback) {
-        readCurrentHeapHighWatermarkAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_HEAP_HIGH_WATERMARK_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_HEAP_HIGH_WATERMARK_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentHeapHighWatermarkAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentHeapHighWatermarkAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_HEAP_HIGH_WATERMARK_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_HEAP_HIGH_WATERMARK_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    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);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class ThreadNetworkDiagnosticsCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 53L;
 
+    private static final long CHANNEL_ATTRIBUTE_ID = 0L;
+    private static final long ROUTING_ROLE_ATTRIBUTE_ID = 1L;
+    private static final long NETWORK_NAME_ATTRIBUTE_ID = 2L;
+    private static final long PAN_ID_ATTRIBUTE_ID = 3L;
+    private static final long EXTENDED_PAN_ID_ATTRIBUTE_ID = 4L;
+    private static final long MESH_LOCAL_PREFIX_ATTRIBUTE_ID = 5L;
+    private static final long OVERRUN_COUNT_ATTRIBUTE_ID = 6L;
+    private static final long NEIGHBOR_TABLE_ATTRIBUTE_ID = 7L;
+    private static final long ROUTE_TABLE_ATTRIBUTE_ID = 8L;
+    private static final long PARTITION_ID_ATTRIBUTE_ID = 9L;
+    private static final long WEIGHTING_ATTRIBUTE_ID = 10L;
+    private static final long DATA_VERSION_ATTRIBUTE_ID = 11L;
+    private static final long STABLE_DATA_VERSION_ATTRIBUTE_ID = 12L;
+    private static final long LEADER_ROUTER_ID_ATTRIBUTE_ID = 13L;
+    private static final long DETACHED_ROLE_COUNT_ATTRIBUTE_ID = 14L;
+    private static final long CHILD_ROLE_COUNT_ATTRIBUTE_ID = 15L;
+    private static final long ROUTER_ROLE_COUNT_ATTRIBUTE_ID = 16L;
+    private static final long LEADER_ROLE_COUNT_ATTRIBUTE_ID = 17L;
+    private static final long ATTACH_ATTEMPT_COUNT_ATTRIBUTE_ID = 18L;
+    private static final long PARTITION_ID_CHANGE_COUNT_ATTRIBUTE_ID = 19L;
+    private static final long BETTER_PARTITION_ATTACH_ATTEMPT_COUNT_ATTRIBUTE_ID = 20L;
+    private static final long PARENT_CHANGE_COUNT_ATTRIBUTE_ID = 21L;
+    private static final long TX_TOTAL_COUNT_ATTRIBUTE_ID = 22L;
+    private static final long TX_UNICAST_COUNT_ATTRIBUTE_ID = 23L;
+    private static final long TX_BROADCAST_COUNT_ATTRIBUTE_ID = 24L;
+    private static final long TX_ACK_REQUESTED_COUNT_ATTRIBUTE_ID = 25L;
+    private static final long TX_ACKED_COUNT_ATTRIBUTE_ID = 26L;
+    private static final long TX_NO_ACK_REQUESTED_COUNT_ATTRIBUTE_ID = 27L;
+    private static final long TX_DATA_COUNT_ATTRIBUTE_ID = 28L;
+    private static final long TX_DATA_POLL_COUNT_ATTRIBUTE_ID = 29L;
+    private static final long TX_BEACON_COUNT_ATTRIBUTE_ID = 30L;
+    private static final long TX_BEACON_REQUEST_COUNT_ATTRIBUTE_ID = 31L;
+    private static final long TX_OTHER_COUNT_ATTRIBUTE_ID = 32L;
+    private static final long TX_RETRY_COUNT_ATTRIBUTE_ID = 33L;
+    private static final long TX_DIRECT_MAX_RETRY_EXPIRY_COUNT_ATTRIBUTE_ID = 34L;
+    private static final long TX_INDIRECT_MAX_RETRY_EXPIRY_COUNT_ATTRIBUTE_ID = 35L;
+    private static final long TX_ERR_CCA_COUNT_ATTRIBUTE_ID = 36L;
+    private static final long TX_ERR_ABORT_COUNT_ATTRIBUTE_ID = 37L;
+    private static final long TX_ERR_BUSY_CHANNEL_COUNT_ATTRIBUTE_ID = 38L;
+    private static final long RX_TOTAL_COUNT_ATTRIBUTE_ID = 39L;
+    private static final long RX_UNICAST_COUNT_ATTRIBUTE_ID = 40L;
+    private static final long RX_BROADCAST_COUNT_ATTRIBUTE_ID = 41L;
+    private static final long RX_DATA_COUNT_ATTRIBUTE_ID = 42L;
+    private static final long RX_DATA_POLL_COUNT_ATTRIBUTE_ID = 43L;
+    private static final long RX_BEACON_COUNT_ATTRIBUTE_ID = 44L;
+    private static final long RX_BEACON_REQUEST_COUNT_ATTRIBUTE_ID = 45L;
+    private static final long RX_OTHER_COUNT_ATTRIBUTE_ID = 46L;
+    private static final long RX_ADDRESS_FILTERED_COUNT_ATTRIBUTE_ID = 47L;
+    private static final long RX_DEST_ADDR_FILTERED_COUNT_ATTRIBUTE_ID = 48L;
+    private static final long RX_DUPLICATED_COUNT_ATTRIBUTE_ID = 49L;
+    private static final long RX_ERR_NO_FRAME_COUNT_ATTRIBUTE_ID = 50L;
+    private static final long RX_ERR_UNKNOWN_NEIGHBOR_COUNT_ATTRIBUTE_ID = 51L;
+    private static final long RX_ERR_INVALID_SRC_ADDR_COUNT_ATTRIBUTE_ID = 52L;
+    private static final long RX_ERR_SEC_COUNT_ATTRIBUTE_ID = 53L;
+    private static final long RX_ERR_FCS_COUNT_ATTRIBUTE_ID = 54L;
+    private static final long RX_ERR_OTHER_COUNT_ATTRIBUTE_ID = 55L;
+    private static final long ACTIVE_TIMESTAMP_ATTRIBUTE_ID = 56L;
+    private static final long PENDING_TIMESTAMP_ATTRIBUTE_ID = 57L;
+    private static final long DELAY_ATTRIBUTE_ID = 58L;
+    private static final long SECURITY_POLICY_ATTRIBUTE_ID = 59L;
+    private static final long CHANNEL_PAGE0_MASK_ATTRIBUTE_ID = 60L;
+    private static final long OPERATIONAL_DATASET_COMPONENTS_ATTRIBUTE_ID = 61L;
+    private static final long ACTIVE_NETWORK_FAULTS_LIST_ATTRIBUTE_ID = 62L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public ThreadNetworkDiagnosticsCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void resetCounts(DefaultClusterCallback callback) {
-      resetCounts(chipClusterPtr, callback, null);
+      resetCounts(callback, 0);
     }
 
     public void resetCounts(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
+      final long commandId = 0L;
 
-    private native void resetCounts(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface ChannelAttributeCallback {
+    public interface ChannelAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface RoutingRoleAttributeCallback {
+    public interface RoutingRoleAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface NetworkNameAttributeCallback {
+    public interface NetworkNameAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable String value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface PanIdAttributeCallback {
+    public interface PanIdAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ExtendedPanIdAttributeCallback {
+    public interface ExtendedPanIdAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MeshLocalPrefixAttributeCallback {
+    public interface MeshLocalPrefixAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable byte[] value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface NeighborTableAttributeCallback {
+    public interface NeighborTableAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.ThreadNetworkDiagnosticsClusterNeighborTableStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface RouteTableAttributeCallback {
+    public interface RouteTableAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.ThreadNetworkDiagnosticsClusterRouteTableStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface PartitionIdAttributeCallback {
+    public interface PartitionIdAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface WeightingAttributeCallback {
+    public interface WeightingAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface DataVersionAttributeCallback {
+    public interface DataVersionAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface StableDataVersionAttributeCallback {
+    public interface StableDataVersionAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface LeaderRouterIdAttributeCallback {
+    public interface LeaderRouterIdAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ActiveTimestampAttributeCallback {
+    public interface ActiveTimestampAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface PendingTimestampAttributeCallback {
+    public interface PendingTimestampAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface DelayAttributeCallback {
+    public interface DelayAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface SecurityPolicyAttributeCallback {
+    public interface SecurityPolicyAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable ChipStructs.ThreadNetworkDiagnosticsClusterSecurityPolicy value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ChannelPage0MaskAttributeCallback {
+    public interface ChannelPage0MaskAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable byte[] value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface OperationalDatasetComponentsAttributeCallback {
+    public interface OperationalDatasetComponentsAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable ChipStructs.ThreadNetworkDiagnosticsClusterOperationalDatasetComponents value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ActiveNetworkFaultsListAttributeCallback {
+    public interface ActiveNetworkFaultsListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Integer> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readChannelAttribute(
         ChannelAttributeCallback callback) {
-        readChannelAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CHANNEL_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CHANNEL_ATTRIBUTE_ID, true);
     }
 
     public void subscribeChannelAttribute(
         ChannelAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeChannelAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CHANNEL_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CHANNEL_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRoutingRoleAttribute(
         RoutingRoleAttributeCallback callback) {
-        readRoutingRoleAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ROUTING_ROLE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ROUTING_ROLE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRoutingRoleAttribute(
         RoutingRoleAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRoutingRoleAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ROUTING_ROLE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ROUTING_ROLE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readNetworkNameAttribute(
         NetworkNameAttributeCallback callback) {
-        readNetworkNameAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NETWORK_NAME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NETWORK_NAME_ATTRIBUTE_ID, true);
     }
 
     public void subscribeNetworkNameAttribute(
         NetworkNameAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNetworkNameAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NETWORK_NAME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NETWORK_NAME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPanIdAttribute(
         PanIdAttributeCallback callback) {
-        readPanIdAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PAN_ID_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PAN_ID_ATTRIBUTE_ID, true);
     }
 
     public void subscribePanIdAttribute(
         PanIdAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePanIdAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PAN_ID_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PAN_ID_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readExtendedPanIdAttribute(
         ExtendedPanIdAttributeCallback callback) {
-        readExtendedPanIdAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EXTENDED_PAN_ID_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EXTENDED_PAN_ID_ATTRIBUTE_ID, true);
     }
 
     public void subscribeExtendedPanIdAttribute(
         ExtendedPanIdAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeExtendedPanIdAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EXTENDED_PAN_ID_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EXTENDED_PAN_ID_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeshLocalPrefixAttribute(
         MeshLocalPrefixAttributeCallback callback) {
-        readMeshLocalPrefixAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MESH_LOCAL_PREFIX_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable byte[] value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MESH_LOCAL_PREFIX_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeshLocalPrefixAttribute(
         MeshLocalPrefixAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeshLocalPrefixAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MESH_LOCAL_PREFIX_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable byte[] value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MESH_LOCAL_PREFIX_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOverrunCountAttribute(
         LongAttributeCallback callback) {
-        readOverrunCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OVERRUN_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OVERRUN_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeOverrunCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOverrunCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OVERRUN_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OVERRUN_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readNeighborTableAttribute(
         NeighborTableAttributeCallback callback) {
-        readNeighborTableAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NEIGHBOR_TABLE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.ThreadNetworkDiagnosticsClusterNeighborTableStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NEIGHBOR_TABLE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeNeighborTableAttribute(
         NeighborTableAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNeighborTableAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NEIGHBOR_TABLE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.ThreadNetworkDiagnosticsClusterNeighborTableStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NEIGHBOR_TABLE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRouteTableAttribute(
         RouteTableAttributeCallback callback) {
-        readRouteTableAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ROUTE_TABLE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.ThreadNetworkDiagnosticsClusterRouteTableStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ROUTE_TABLE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRouteTableAttribute(
         RouteTableAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRouteTableAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ROUTE_TABLE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.ThreadNetworkDiagnosticsClusterRouteTableStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ROUTE_TABLE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPartitionIdAttribute(
         PartitionIdAttributeCallback callback) {
-        readPartitionIdAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PARTITION_ID_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PARTITION_ID_ATTRIBUTE_ID, true);
     }
 
     public void subscribePartitionIdAttribute(
         PartitionIdAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePartitionIdAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PARTITION_ID_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PARTITION_ID_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readWeightingAttribute(
         WeightingAttributeCallback callback) {
-        readWeightingAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WEIGHTING_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, WEIGHTING_ATTRIBUTE_ID, true);
     }
 
     public void subscribeWeightingAttribute(
         WeightingAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeWeightingAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WEIGHTING_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, WEIGHTING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDataVersionAttribute(
         DataVersionAttributeCallback callback) {
-        readDataVersionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DATA_VERSION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DATA_VERSION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDataVersionAttribute(
         DataVersionAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDataVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DATA_VERSION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DATA_VERSION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readStableDataVersionAttribute(
         StableDataVersionAttributeCallback callback) {
-        readStableDataVersionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STABLE_DATA_VERSION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, STABLE_DATA_VERSION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeStableDataVersionAttribute(
         StableDataVersionAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeStableDataVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STABLE_DATA_VERSION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, STABLE_DATA_VERSION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLeaderRouterIdAttribute(
         LeaderRouterIdAttributeCallback callback) {
-        readLeaderRouterIdAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEADER_ROUTER_ID_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LEADER_ROUTER_ID_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLeaderRouterIdAttribute(
         LeaderRouterIdAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLeaderRouterIdAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEADER_ROUTER_ID_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LEADER_ROUTER_ID_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDetachedRoleCountAttribute(
         IntegerAttributeCallback callback) {
-        readDetachedRoleCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DETACHED_ROLE_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DETACHED_ROLE_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDetachedRoleCountAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDetachedRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DETACHED_ROLE_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DETACHED_ROLE_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readChildRoleCountAttribute(
         IntegerAttributeCallback callback) {
-        readChildRoleCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CHILD_ROLE_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CHILD_ROLE_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeChildRoleCountAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeChildRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CHILD_ROLE_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CHILD_ROLE_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRouterRoleCountAttribute(
         IntegerAttributeCallback callback) {
-        readRouterRoleCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ROUTER_ROLE_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ROUTER_ROLE_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRouterRoleCountAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRouterRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ROUTER_ROLE_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ROUTER_ROLE_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLeaderRoleCountAttribute(
         IntegerAttributeCallback callback) {
-        readLeaderRoleCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEADER_ROLE_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LEADER_ROLE_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLeaderRoleCountAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLeaderRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEADER_ROLE_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LEADER_ROLE_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttachAttemptCountAttribute(
         IntegerAttributeCallback callback) {
-        readAttachAttemptCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTACH_ATTEMPT_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTACH_ATTEMPT_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttachAttemptCountAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttachAttemptCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTACH_ATTEMPT_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTACH_ATTEMPT_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPartitionIdChangeCountAttribute(
         IntegerAttributeCallback callback) {
-        readPartitionIdChangeCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PARTITION_ID_CHANGE_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PARTITION_ID_CHANGE_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribePartitionIdChangeCountAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePartitionIdChangeCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PARTITION_ID_CHANGE_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PARTITION_ID_CHANGE_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBetterPartitionAttachAttemptCountAttribute(
         IntegerAttributeCallback callback) {
-        readBetterPartitionAttachAttemptCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BETTER_PARTITION_ATTACH_ATTEMPT_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BETTER_PARTITION_ATTACH_ATTEMPT_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBetterPartitionAttachAttemptCountAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBetterPartitionAttachAttemptCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BETTER_PARTITION_ATTACH_ATTEMPT_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BETTER_PARTITION_ATTACH_ATTEMPT_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readParentChangeCountAttribute(
         IntegerAttributeCallback callback) {
-        readParentChangeCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PARENT_CHANGE_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PARENT_CHANGE_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeParentChangeCountAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeParentChangeCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PARENT_CHANGE_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PARENT_CHANGE_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTxTotalCountAttribute(
         LongAttributeCallback callback) {
-        readTxTotalCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_TOTAL_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TX_TOTAL_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTxTotalCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTxTotalCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_TOTAL_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TX_TOTAL_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTxUnicastCountAttribute(
         LongAttributeCallback callback) {
-        readTxUnicastCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_UNICAST_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TX_UNICAST_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTxUnicastCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTxUnicastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_UNICAST_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TX_UNICAST_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTxBroadcastCountAttribute(
         LongAttributeCallback callback) {
-        readTxBroadcastCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_BROADCAST_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TX_BROADCAST_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTxBroadcastCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTxBroadcastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_BROADCAST_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TX_BROADCAST_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTxAckRequestedCountAttribute(
         LongAttributeCallback callback) {
-        readTxAckRequestedCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_ACK_REQUESTED_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TX_ACK_REQUESTED_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTxAckRequestedCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTxAckRequestedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_ACK_REQUESTED_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TX_ACK_REQUESTED_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTxAckedCountAttribute(
         LongAttributeCallback callback) {
-        readTxAckedCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_ACKED_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TX_ACKED_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTxAckedCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTxAckedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_ACKED_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TX_ACKED_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTxNoAckRequestedCountAttribute(
         LongAttributeCallback callback) {
-        readTxNoAckRequestedCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_NO_ACK_REQUESTED_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TX_NO_ACK_REQUESTED_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTxNoAckRequestedCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTxNoAckRequestedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_NO_ACK_REQUESTED_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TX_NO_ACK_REQUESTED_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTxDataCountAttribute(
         LongAttributeCallback callback) {
-        readTxDataCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_DATA_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TX_DATA_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTxDataCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTxDataCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_DATA_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TX_DATA_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTxDataPollCountAttribute(
         LongAttributeCallback callback) {
-        readTxDataPollCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_DATA_POLL_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TX_DATA_POLL_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTxDataPollCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTxDataPollCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_DATA_POLL_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TX_DATA_POLL_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTxBeaconCountAttribute(
         LongAttributeCallback callback) {
-        readTxBeaconCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_BEACON_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TX_BEACON_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTxBeaconCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTxBeaconCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_BEACON_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TX_BEACON_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTxBeaconRequestCountAttribute(
         LongAttributeCallback callback) {
-        readTxBeaconRequestCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_BEACON_REQUEST_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TX_BEACON_REQUEST_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTxBeaconRequestCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTxBeaconRequestCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_BEACON_REQUEST_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TX_BEACON_REQUEST_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTxOtherCountAttribute(
         LongAttributeCallback callback) {
-        readTxOtherCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_OTHER_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TX_OTHER_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTxOtherCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTxOtherCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_OTHER_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TX_OTHER_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTxRetryCountAttribute(
         LongAttributeCallback callback) {
-        readTxRetryCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_RETRY_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TX_RETRY_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTxRetryCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTxRetryCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_RETRY_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TX_RETRY_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTxDirectMaxRetryExpiryCountAttribute(
         LongAttributeCallback callback) {
-        readTxDirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_DIRECT_MAX_RETRY_EXPIRY_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TX_DIRECT_MAX_RETRY_EXPIRY_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTxDirectMaxRetryExpiryCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTxDirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_DIRECT_MAX_RETRY_EXPIRY_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TX_DIRECT_MAX_RETRY_EXPIRY_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTxIndirectMaxRetryExpiryCountAttribute(
         LongAttributeCallback callback) {
-        readTxIndirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_INDIRECT_MAX_RETRY_EXPIRY_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TX_INDIRECT_MAX_RETRY_EXPIRY_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTxIndirectMaxRetryExpiryCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTxIndirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_INDIRECT_MAX_RETRY_EXPIRY_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TX_INDIRECT_MAX_RETRY_EXPIRY_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTxErrCcaCountAttribute(
         LongAttributeCallback callback) {
-        readTxErrCcaCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_ERR_CCA_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TX_ERR_CCA_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTxErrCcaCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTxErrCcaCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_ERR_CCA_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TX_ERR_CCA_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTxErrAbortCountAttribute(
         LongAttributeCallback callback) {
-        readTxErrAbortCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_ERR_ABORT_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TX_ERR_ABORT_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTxErrAbortCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTxErrAbortCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_ERR_ABORT_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TX_ERR_ABORT_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTxErrBusyChannelCountAttribute(
         LongAttributeCallback callback) {
-        readTxErrBusyChannelCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_ERR_BUSY_CHANNEL_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TX_ERR_BUSY_CHANNEL_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTxErrBusyChannelCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTxErrBusyChannelCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_ERR_BUSY_CHANNEL_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TX_ERR_BUSY_CHANNEL_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRxTotalCountAttribute(
         LongAttributeCallback callback) {
-        readRxTotalCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_TOTAL_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RX_TOTAL_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRxTotalCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRxTotalCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_TOTAL_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RX_TOTAL_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRxUnicastCountAttribute(
         LongAttributeCallback callback) {
-        readRxUnicastCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_UNICAST_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RX_UNICAST_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRxUnicastCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRxUnicastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_UNICAST_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RX_UNICAST_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRxBroadcastCountAttribute(
         LongAttributeCallback callback) {
-        readRxBroadcastCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_BROADCAST_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RX_BROADCAST_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRxBroadcastCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRxBroadcastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_BROADCAST_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RX_BROADCAST_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRxDataCountAttribute(
         LongAttributeCallback callback) {
-        readRxDataCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_DATA_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RX_DATA_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRxDataCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRxDataCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_DATA_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RX_DATA_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRxDataPollCountAttribute(
         LongAttributeCallback callback) {
-        readRxDataPollCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_DATA_POLL_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RX_DATA_POLL_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRxDataPollCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRxDataPollCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_DATA_POLL_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RX_DATA_POLL_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRxBeaconCountAttribute(
         LongAttributeCallback callback) {
-        readRxBeaconCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_BEACON_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RX_BEACON_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRxBeaconCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRxBeaconCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_BEACON_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RX_BEACON_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRxBeaconRequestCountAttribute(
         LongAttributeCallback callback) {
-        readRxBeaconRequestCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_BEACON_REQUEST_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RX_BEACON_REQUEST_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRxBeaconRequestCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRxBeaconRequestCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_BEACON_REQUEST_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RX_BEACON_REQUEST_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRxOtherCountAttribute(
         LongAttributeCallback callback) {
-        readRxOtherCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_OTHER_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RX_OTHER_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRxOtherCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRxOtherCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_OTHER_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RX_OTHER_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRxAddressFilteredCountAttribute(
         LongAttributeCallback callback) {
-        readRxAddressFilteredCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_ADDRESS_FILTERED_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RX_ADDRESS_FILTERED_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRxAddressFilteredCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRxAddressFilteredCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_ADDRESS_FILTERED_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RX_ADDRESS_FILTERED_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRxDestAddrFilteredCountAttribute(
         LongAttributeCallback callback) {
-        readRxDestAddrFilteredCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_DEST_ADDR_FILTERED_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RX_DEST_ADDR_FILTERED_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRxDestAddrFilteredCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRxDestAddrFilteredCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_DEST_ADDR_FILTERED_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RX_DEST_ADDR_FILTERED_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRxDuplicatedCountAttribute(
         LongAttributeCallback callback) {
-        readRxDuplicatedCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_DUPLICATED_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RX_DUPLICATED_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRxDuplicatedCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRxDuplicatedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_DUPLICATED_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RX_DUPLICATED_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRxErrNoFrameCountAttribute(
         LongAttributeCallback callback) {
-        readRxErrNoFrameCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_ERR_NO_FRAME_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RX_ERR_NO_FRAME_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRxErrNoFrameCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRxErrNoFrameCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_ERR_NO_FRAME_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RX_ERR_NO_FRAME_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRxErrUnknownNeighborCountAttribute(
         LongAttributeCallback callback) {
-        readRxErrUnknownNeighborCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_ERR_UNKNOWN_NEIGHBOR_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RX_ERR_UNKNOWN_NEIGHBOR_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRxErrUnknownNeighborCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRxErrUnknownNeighborCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_ERR_UNKNOWN_NEIGHBOR_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RX_ERR_UNKNOWN_NEIGHBOR_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRxErrInvalidSrcAddrCountAttribute(
         LongAttributeCallback callback) {
-        readRxErrInvalidSrcAddrCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_ERR_INVALID_SRC_ADDR_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RX_ERR_INVALID_SRC_ADDR_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRxErrInvalidSrcAddrCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRxErrInvalidSrcAddrCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_ERR_INVALID_SRC_ADDR_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RX_ERR_INVALID_SRC_ADDR_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRxErrSecCountAttribute(
         LongAttributeCallback callback) {
-        readRxErrSecCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_ERR_SEC_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RX_ERR_SEC_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRxErrSecCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRxErrSecCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_ERR_SEC_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RX_ERR_SEC_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRxErrFcsCountAttribute(
         LongAttributeCallback callback) {
-        readRxErrFcsCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_ERR_FCS_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RX_ERR_FCS_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRxErrFcsCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRxErrFcsCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_ERR_FCS_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RX_ERR_FCS_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRxErrOtherCountAttribute(
         LongAttributeCallback callback) {
-        readRxErrOtherCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_ERR_OTHER_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RX_ERR_OTHER_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRxErrOtherCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRxErrOtherCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RX_ERR_OTHER_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RX_ERR_OTHER_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActiveTimestampAttribute(
         ActiveTimestampAttributeCallback callback) {
-        readActiveTimestampAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_TIMESTAMP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_TIMESTAMP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActiveTimestampAttribute(
         ActiveTimestampAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActiveTimestampAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_TIMESTAMP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_TIMESTAMP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPendingTimestampAttribute(
         PendingTimestampAttributeCallback callback) {
-        readPendingTimestampAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PENDING_TIMESTAMP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PENDING_TIMESTAMP_ATTRIBUTE_ID, true);
     }
 
     public void subscribePendingTimestampAttribute(
         PendingTimestampAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePendingTimestampAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PENDING_TIMESTAMP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PENDING_TIMESTAMP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDelayAttribute(
         DelayAttributeCallback callback) {
-        readDelayAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DELAY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DELAY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDelayAttribute(
         DelayAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDelayAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DELAY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DELAY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSecurityPolicyAttribute(
         SecurityPolicyAttributeCallback callback) {
-        readSecurityPolicyAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SECURITY_POLICY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable ChipStructs.ThreadNetworkDiagnosticsClusterSecurityPolicy value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SECURITY_POLICY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSecurityPolicyAttribute(
         SecurityPolicyAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSecurityPolicyAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SECURITY_POLICY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable ChipStructs.ThreadNetworkDiagnosticsClusterSecurityPolicy value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SECURITY_POLICY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readChannelPage0MaskAttribute(
         ChannelPage0MaskAttributeCallback callback) {
-        readChannelPage0MaskAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CHANNEL_PAGE0_MASK_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable byte[] value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CHANNEL_PAGE0_MASK_ATTRIBUTE_ID, true);
     }
 
     public void subscribeChannelPage0MaskAttribute(
         ChannelPage0MaskAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeChannelPage0MaskAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CHANNEL_PAGE0_MASK_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable byte[] value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CHANNEL_PAGE0_MASK_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOperationalDatasetComponentsAttribute(
         OperationalDatasetComponentsAttributeCallback callback) {
-        readOperationalDatasetComponentsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPERATIONAL_DATASET_COMPONENTS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable ChipStructs.ThreadNetworkDiagnosticsClusterOperationalDatasetComponents value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OPERATIONAL_DATASET_COMPONENTS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeOperationalDatasetComponentsAttribute(
         OperationalDatasetComponentsAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOperationalDatasetComponentsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPERATIONAL_DATASET_COMPONENTS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable ChipStructs.ThreadNetworkDiagnosticsClusterOperationalDatasetComponents value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OPERATIONAL_DATASET_COMPONENTS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActiveNetworkFaultsListAttribute(
         ActiveNetworkFaultsListAttributeCallback callback) {
-        readActiveNetworkFaultsListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_NETWORK_FAULTS_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_NETWORK_FAULTS_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActiveNetworkFaultsListAttribute(
         ActiveNetworkFaultsListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActiveNetworkFaultsListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_NETWORK_FAULTS_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_NETWORK_FAULTS_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readChannelAttribute(long chipClusterPtr, ChannelAttributeCallback callback);
-
-    private native void subscribeChannelAttribute(long chipClusterPtr, ChannelAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRoutingRoleAttribute(long chipClusterPtr, RoutingRoleAttributeCallback callback);
-
-    private native void subscribeRoutingRoleAttribute(long chipClusterPtr, RoutingRoleAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readNetworkNameAttribute(long chipClusterPtr, NetworkNameAttributeCallback callback);
-
-    private native void subscribeNetworkNameAttribute(long chipClusterPtr, NetworkNameAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPanIdAttribute(long chipClusterPtr, PanIdAttributeCallback callback);
-
-    private native void subscribePanIdAttribute(long chipClusterPtr, PanIdAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readExtendedPanIdAttribute(long chipClusterPtr, ExtendedPanIdAttributeCallback callback);
-
-    private native void subscribeExtendedPanIdAttribute(long chipClusterPtr, ExtendedPanIdAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMeshLocalPrefixAttribute(long chipClusterPtr, MeshLocalPrefixAttributeCallback callback);
-
-    private native void subscribeMeshLocalPrefixAttribute(long chipClusterPtr, MeshLocalPrefixAttributeCallback 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 readNeighborTableAttribute(long chipClusterPtr, NeighborTableAttributeCallback callback);
-
-    private native void subscribeNeighborTableAttribute(long chipClusterPtr, NeighborTableAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRouteTableAttribute(long chipClusterPtr, RouteTableAttributeCallback callback);
-
-    private native void subscribeRouteTableAttribute(long chipClusterPtr, RouteTableAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPartitionIdAttribute(long chipClusterPtr, PartitionIdAttributeCallback callback);
-
-    private native void subscribePartitionIdAttribute(long chipClusterPtr, PartitionIdAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readWeightingAttribute(long chipClusterPtr, WeightingAttributeCallback callback);
-
-    private native void subscribeWeightingAttribute(long chipClusterPtr, WeightingAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readDataVersionAttribute(long chipClusterPtr, DataVersionAttributeCallback callback);
-
-    private native void subscribeDataVersionAttribute(long chipClusterPtr, DataVersionAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readStableDataVersionAttribute(long chipClusterPtr, StableDataVersionAttributeCallback callback);
-
-    private native void subscribeStableDataVersionAttribute(long chipClusterPtr, StableDataVersionAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLeaderRouterIdAttribute(long chipClusterPtr, LeaderRouterIdAttributeCallback callback);
-
-    private native void subscribeLeaderRouterIdAttribute(long chipClusterPtr, LeaderRouterIdAttributeCallback 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);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    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, ActiveTimestampAttributeCallback callback);
-
-    private native void subscribeActiveTimestampAttribute(long chipClusterPtr, ActiveTimestampAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPendingTimestampAttribute(long chipClusterPtr, PendingTimestampAttributeCallback callback);
-
-    private native void subscribePendingTimestampAttribute(long chipClusterPtr, PendingTimestampAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readDelayAttribute(long chipClusterPtr, DelayAttributeCallback callback);
-
-    private native void subscribeDelayAttribute(long chipClusterPtr, DelayAttributeCallback 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 readChannelPage0MaskAttribute(long chipClusterPtr, ChannelPage0MaskAttributeCallback callback);
-
-    private native void subscribeChannelPage0MaskAttribute(long chipClusterPtr, ChannelPage0MaskAttributeCallback 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 readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class WiFiNetworkDiagnosticsCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 54L;
 
+    private static final long BSSID_ATTRIBUTE_ID = 0L;
+    private static final long SECURITY_TYPE_ATTRIBUTE_ID = 1L;
+    private static final long WI_FI_VERSION_ATTRIBUTE_ID = 2L;
+    private static final long CHANNEL_NUMBER_ATTRIBUTE_ID = 3L;
+    private static final long RSSI_ATTRIBUTE_ID = 4L;
+    private static final long BEACON_LOST_COUNT_ATTRIBUTE_ID = 5L;
+    private static final long BEACON_RX_COUNT_ATTRIBUTE_ID = 6L;
+    private static final long PACKET_MULTICAST_RX_COUNT_ATTRIBUTE_ID = 7L;
+    private static final long PACKET_MULTICAST_TX_COUNT_ATTRIBUTE_ID = 8L;
+    private static final long PACKET_UNICAST_RX_COUNT_ATTRIBUTE_ID = 9L;
+    private static final long PACKET_UNICAST_TX_COUNT_ATTRIBUTE_ID = 10L;
+    private static final long CURRENT_MAX_RATE_ATTRIBUTE_ID = 11L;
+    private static final long OVERRUN_COUNT_ATTRIBUTE_ID = 12L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public WiFiNetworkDiagnosticsCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void resetCounts(DefaultClusterCallback callback) {
-      resetCounts(chipClusterPtr, callback, null);
+      resetCounts(callback, 0);
     }
 
     public void resetCounts(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
+      final long commandId = 0L;
 
-    private native void resetCounts(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface BssidAttributeCallback {
+    public interface BssidAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable byte[] value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface SecurityTypeAttributeCallback {
+    public interface SecurityTypeAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface WiFiVersionAttributeCallback {
+    public interface WiFiVersionAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ChannelNumberAttributeCallback {
+    public interface ChannelNumberAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface RssiAttributeCallback {
+    public interface RssiAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface BeaconLostCountAttributeCallback {
+    public interface BeaconLostCountAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface BeaconRxCountAttributeCallback {
+    public interface BeaconRxCountAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface PacketMulticastRxCountAttributeCallback {
+    public interface PacketMulticastRxCountAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface PacketMulticastTxCountAttributeCallback {
+    public interface PacketMulticastTxCountAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface PacketUnicastRxCountAttributeCallback {
+    public interface PacketUnicastRxCountAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface PacketUnicastTxCountAttributeCallback {
+    public interface PacketUnicastTxCountAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface CurrentMaxRateAttributeCallback {
+    public interface CurrentMaxRateAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface OverrunCountAttributeCallback {
+    public interface OverrunCountAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readBssidAttribute(
         BssidAttributeCallback callback) {
-        readBssidAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BSSID_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable byte[] value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BSSID_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBssidAttribute(
         BssidAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBssidAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BSSID_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable byte[] value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BSSID_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSecurityTypeAttribute(
         SecurityTypeAttributeCallback callback) {
-        readSecurityTypeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SECURITY_TYPE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SECURITY_TYPE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSecurityTypeAttribute(
         SecurityTypeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSecurityTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SECURITY_TYPE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SECURITY_TYPE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readWiFiVersionAttribute(
         WiFiVersionAttributeCallback callback) {
-        readWiFiVersionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WI_FI_VERSION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, WI_FI_VERSION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeWiFiVersionAttribute(
         WiFiVersionAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeWiFiVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WI_FI_VERSION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, WI_FI_VERSION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readChannelNumberAttribute(
         ChannelNumberAttributeCallback callback) {
-        readChannelNumberAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CHANNEL_NUMBER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CHANNEL_NUMBER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeChannelNumberAttribute(
         ChannelNumberAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeChannelNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CHANNEL_NUMBER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CHANNEL_NUMBER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRssiAttribute(
         RssiAttributeCallback callback) {
-        readRssiAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RSSI_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RSSI_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRssiAttribute(
         RssiAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRssiAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RSSI_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RSSI_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBeaconLostCountAttribute(
         BeaconLostCountAttributeCallback callback) {
-        readBeaconLostCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BEACON_LOST_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BEACON_LOST_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBeaconLostCountAttribute(
         BeaconLostCountAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBeaconLostCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BEACON_LOST_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BEACON_LOST_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBeaconRxCountAttribute(
         BeaconRxCountAttributeCallback callback) {
-        readBeaconRxCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BEACON_RX_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BEACON_RX_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBeaconRxCountAttribute(
         BeaconRxCountAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBeaconRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BEACON_RX_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BEACON_RX_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPacketMulticastRxCountAttribute(
         PacketMulticastRxCountAttributeCallback callback) {
-        readPacketMulticastRxCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PACKET_MULTICAST_RX_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PACKET_MULTICAST_RX_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribePacketMulticastRxCountAttribute(
         PacketMulticastRxCountAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePacketMulticastRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PACKET_MULTICAST_RX_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PACKET_MULTICAST_RX_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPacketMulticastTxCountAttribute(
         PacketMulticastTxCountAttributeCallback callback) {
-        readPacketMulticastTxCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PACKET_MULTICAST_TX_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PACKET_MULTICAST_TX_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribePacketMulticastTxCountAttribute(
         PacketMulticastTxCountAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePacketMulticastTxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PACKET_MULTICAST_TX_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PACKET_MULTICAST_TX_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPacketUnicastRxCountAttribute(
         PacketUnicastRxCountAttributeCallback callback) {
-        readPacketUnicastRxCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PACKET_UNICAST_RX_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PACKET_UNICAST_RX_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribePacketUnicastRxCountAttribute(
         PacketUnicastRxCountAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePacketUnicastRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PACKET_UNICAST_RX_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PACKET_UNICAST_RX_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPacketUnicastTxCountAttribute(
         PacketUnicastTxCountAttributeCallback callback) {
-        readPacketUnicastTxCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PACKET_UNICAST_TX_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PACKET_UNICAST_TX_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribePacketUnicastTxCountAttribute(
         PacketUnicastTxCountAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePacketUnicastTxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PACKET_UNICAST_TX_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PACKET_UNICAST_TX_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentMaxRateAttribute(
         CurrentMaxRateAttributeCallback callback) {
-        readCurrentMaxRateAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_MAX_RATE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_MAX_RATE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentMaxRateAttribute(
         CurrentMaxRateAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentMaxRateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_MAX_RATE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_MAX_RATE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOverrunCountAttribute(
         OverrunCountAttributeCallback callback) {
-        readOverrunCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OVERRUN_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OVERRUN_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeOverrunCountAttribute(
         OverrunCountAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOverrunCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OVERRUN_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OVERRUN_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readBssidAttribute(long chipClusterPtr, BssidAttributeCallback callback);
-
-    private native void subscribeBssidAttribute(long chipClusterPtr, BssidAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSecurityTypeAttribute(long chipClusterPtr, SecurityTypeAttributeCallback callback);
-
-    private native void subscribeSecurityTypeAttribute(long chipClusterPtr, SecurityTypeAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readWiFiVersionAttribute(long chipClusterPtr, WiFiVersionAttributeCallback callback);
-
-    private native void subscribeWiFiVersionAttribute(long chipClusterPtr, WiFiVersionAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readChannelNumberAttribute(long chipClusterPtr, ChannelNumberAttributeCallback callback);
-
-    private native void subscribeChannelNumberAttribute(long chipClusterPtr, ChannelNumberAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRssiAttribute(long chipClusterPtr, RssiAttributeCallback callback);
-
-    private native void subscribeRssiAttribute(long chipClusterPtr, RssiAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBeaconLostCountAttribute(long chipClusterPtr, BeaconLostCountAttributeCallback callback);
-
-    private native void subscribeBeaconLostCountAttribute(long chipClusterPtr, BeaconLostCountAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBeaconRxCountAttribute(long chipClusterPtr, BeaconRxCountAttributeCallback callback);
-
-    private native void subscribeBeaconRxCountAttribute(long chipClusterPtr, BeaconRxCountAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPacketMulticastRxCountAttribute(long chipClusterPtr, PacketMulticastRxCountAttributeCallback callback);
-
-    private native void subscribePacketMulticastRxCountAttribute(long chipClusterPtr, PacketMulticastRxCountAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPacketMulticastTxCountAttribute(long chipClusterPtr, PacketMulticastTxCountAttributeCallback callback);
-
-    private native void subscribePacketMulticastTxCountAttribute(long chipClusterPtr, PacketMulticastTxCountAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPacketUnicastRxCountAttribute(long chipClusterPtr, PacketUnicastRxCountAttributeCallback callback);
-
-    private native void subscribePacketUnicastRxCountAttribute(long chipClusterPtr, PacketUnicastRxCountAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPacketUnicastTxCountAttribute(long chipClusterPtr, PacketUnicastTxCountAttributeCallback callback);
-
-    private native void subscribePacketUnicastTxCountAttribute(long chipClusterPtr, PacketUnicastTxCountAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readCurrentMaxRateAttribute(long chipClusterPtr, CurrentMaxRateAttributeCallback callback);
-
-    private native void subscribeCurrentMaxRateAttribute(long chipClusterPtr, CurrentMaxRateAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readOverrunCountAttribute(long chipClusterPtr, OverrunCountAttributeCallback callback);
-
-    private native void subscribeOverrunCountAttribute(long chipClusterPtr, OverrunCountAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class EthernetNetworkDiagnosticsCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 55L;
 
+    private static final long P_H_Y_RATE_ATTRIBUTE_ID = 0L;
+    private static final long FULL_DUPLEX_ATTRIBUTE_ID = 1L;
+    private static final long PACKET_RX_COUNT_ATTRIBUTE_ID = 2L;
+    private static final long PACKET_TX_COUNT_ATTRIBUTE_ID = 3L;
+    private static final long TX_ERR_COUNT_ATTRIBUTE_ID = 4L;
+    private static final long COLLISION_COUNT_ATTRIBUTE_ID = 5L;
+    private static final long OVERRUN_COUNT_ATTRIBUTE_ID = 6L;
+    private static final long CARRIER_DETECT_ATTRIBUTE_ID = 7L;
+    private static final long TIME_SINCE_RESET_ATTRIBUTE_ID = 8L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public EthernetNetworkDiagnosticsCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void resetCounts(DefaultClusterCallback callback) {
-      resetCounts(chipClusterPtr, callback, null);
+      resetCounts(callback, 0);
     }
 
     public void resetCounts(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
+      final long commandId = 0L;
 
-    private native void resetCounts(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface PHYRateAttributeCallback {
+    public interface PHYRateAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface FullDuplexAttributeCallback {
+    public interface FullDuplexAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Boolean value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface CarrierDetectAttributeCallback {
+    public interface CarrierDetectAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Boolean value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readPHYRateAttribute(
         PHYRateAttributeCallback callback) {
-        readPHYRateAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, P_H_Y_RATE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, P_H_Y_RATE_ATTRIBUTE_ID, true);
     }
 
     public void subscribePHYRateAttribute(
         PHYRateAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePHYRateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, P_H_Y_RATE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, P_H_Y_RATE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFullDuplexAttribute(
         FullDuplexAttributeCallback callback) {
-        readFullDuplexAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FULL_DUPLEX_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FULL_DUPLEX_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFullDuplexAttribute(
         FullDuplexAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFullDuplexAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FULL_DUPLEX_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FULL_DUPLEX_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPacketRxCountAttribute(
         LongAttributeCallback callback) {
-        readPacketRxCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PACKET_RX_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PACKET_RX_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribePacketRxCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePacketRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PACKET_RX_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PACKET_RX_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPacketTxCountAttribute(
         LongAttributeCallback callback) {
-        readPacketTxCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PACKET_TX_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PACKET_TX_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribePacketTxCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePacketTxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PACKET_TX_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PACKET_TX_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTxErrCountAttribute(
         LongAttributeCallback callback) {
-        readTxErrCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_ERR_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TX_ERR_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTxErrCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTxErrCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TX_ERR_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TX_ERR_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCollisionCountAttribute(
         LongAttributeCallback callback) {
-        readCollisionCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLLISION_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COLLISION_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCollisionCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCollisionCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLLISION_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COLLISION_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOverrunCountAttribute(
         LongAttributeCallback callback) {
-        readOverrunCountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OVERRUN_COUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OVERRUN_COUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeOverrunCountAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOverrunCountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OVERRUN_COUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OVERRUN_COUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCarrierDetectAttribute(
         CarrierDetectAttributeCallback callback) {
-        readCarrierDetectAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CARRIER_DETECT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CARRIER_DETECT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCarrierDetectAttribute(
         CarrierDetectAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCarrierDetectAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CARRIER_DETECT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CARRIER_DETECT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTimeSinceResetAttribute(
         LongAttributeCallback callback) {
-        readTimeSinceResetAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TIME_SINCE_RESET_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TIME_SINCE_RESET_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTimeSinceResetAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTimeSinceResetAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TIME_SINCE_RESET_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TIME_SINCE_RESET_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readPHYRateAttribute(long chipClusterPtr, PHYRateAttributeCallback callback);
-
-    private native void subscribePHYRateAttribute(long chipClusterPtr, PHYRateAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFullDuplexAttribute(long chipClusterPtr, FullDuplexAttributeCallback callback);
-
-    private native void subscribeFullDuplexAttribute(long chipClusterPtr, FullDuplexAttributeCallback 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, CarrierDetectAttributeCallback callback);
-
-    private native void subscribeCarrierDetectAttribute(long chipClusterPtr, CarrierDetectAttributeCallback 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);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class TimeSynchronizationCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 56L;
 
+    private static final long U_T_C_TIME_ATTRIBUTE_ID = 0L;
+    private static final long GRANULARITY_ATTRIBUTE_ID = 1L;
+    private static final long TIME_SOURCE_ATTRIBUTE_ID = 2L;
+    private static final long TRUSTED_TIME_SOURCE_ATTRIBUTE_ID = 3L;
+    private static final long DEFAULT_N_T_P_ATTRIBUTE_ID = 4L;
+    private static final long TIME_ZONE_ATTRIBUTE_ID = 5L;
+    private static final long D_S_T_OFFSET_ATTRIBUTE_ID = 6L;
+    private static final long LOCAL_TIME_ATTRIBUTE_ID = 7L;
+    private static final long TIME_ZONE_DATABASE_ATTRIBUTE_ID = 8L;
+    private static final long N_T_P_SERVER_AVAILABLE_ATTRIBUTE_ID = 9L;
+    private static final long TIME_ZONE_LIST_MAX_SIZE_ATTRIBUTE_ID = 10L;
+    private static final long D_S_T_OFFSET_LIST_MAX_SIZE_ATTRIBUTE_ID = 11L;
+    private static final long SUPPORTS_D_N_S_RESOLVE_ATTRIBUTE_ID = 12L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public TimeSynchronizationCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void setUTCTime(DefaultClusterCallback callback, Long UTCTime, Integer granularity, Optional<Integer> timeSource) {
-      setUTCTime(chipClusterPtr, callback, UTCTime, granularity, timeSource, null);
+      setUTCTime(callback, UTCTime, granularity, timeSource, 0);
     }
 
     public void setUTCTime(DefaultClusterCallback callback, Long UTCTime, Integer granularity, Optional<Integer> timeSource, int timedInvokeTimeoutMs) {
-      setUTCTime(chipClusterPtr, callback, UTCTime, granularity, timeSource, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long UTCTimeFieldID = 0L;
+      BaseTLVType UTCTimetlvValue = new UIntType(UTCTime);
+      elements.add(new StructElement(UTCTimeFieldID, UTCTimetlvValue));
+
+      final long granularityFieldID = 1L;
+      BaseTLVType granularitytlvValue = new UIntType(granularity);
+      elements.add(new StructElement(granularityFieldID, granularitytlvValue));
+
+      final long timeSourceFieldID = 2L;
+      BaseTLVType timeSourcetlvValue = timeSource.<BaseTLVType>map((nonOptionaltimeSource) -> new UIntType(nonOptionaltimeSource)).orElse(new EmptyType());
+      elements.add(new StructElement(timeSourceFieldID, timeSourcetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void setTrustedTimeSource(DefaultClusterCallback callback, @Nullable ChipStructs.TimeSynchronizationClusterFabricScopedTrustedTimeSourceStruct trustedTimeSource) {
-      setTrustedTimeSource(chipClusterPtr, callback, trustedTimeSource, null);
+      setTrustedTimeSource(callback, trustedTimeSource, 0);
     }
 
     public void setTrustedTimeSource(DefaultClusterCallback callback, @Nullable ChipStructs.TimeSynchronizationClusterFabricScopedTrustedTimeSourceStruct trustedTimeSource, int timedInvokeTimeoutMs) {
-      setTrustedTimeSource(chipClusterPtr, callback, trustedTimeSource, timedInvokeTimeoutMs);
+      final long commandId = 1L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long trustedTimeSourceFieldID = 0L;
+      BaseTLVType trustedTimeSourcetlvValue = trustedTimeSource != null ? trustedTimeSource.encodeTlv() : new NullType();
+      elements.add(new StructElement(trustedTimeSourceFieldID, trustedTimeSourcetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void setTimeZone(SetTimeZoneResponseCallback callback, ArrayList<ChipStructs.TimeSynchronizationClusterTimeZoneStruct> timeZone) {
-      setTimeZone(chipClusterPtr, callback, timeZone, null);
+      setTimeZone(callback, timeZone, 0);
     }
 
     public void setTimeZone(SetTimeZoneResponseCallback callback, ArrayList<ChipStructs.TimeSynchronizationClusterTimeZoneStruct> timeZone, int timedInvokeTimeoutMs) {
-      setTimeZone(chipClusterPtr, callback, timeZone, timedInvokeTimeoutMs);
+      final long commandId = 2L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long timeZoneFieldID = 0L;
+      BaseTLVType timeZonetlvValue = ArrayType.generateArrayType(timeZone, (elementtimeZone) -> elementtimeZone.encodeTlv());
+      elements.add(new StructElement(timeZoneFieldID, timeZonetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long DSTOffsetRequiredFieldID = 0L;
+          Boolean DSTOffsetRequired = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == DSTOffsetRequiredFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                DSTOffsetRequired = castingValue.value(Boolean.class);
+              }
+            }
+          }
+          callback.onSuccess(DSTOffsetRequired);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void setDSTOffset(DefaultClusterCallback callback, ArrayList<ChipStructs.TimeSynchronizationClusterDSTOffsetStruct> DSTOffset) {
-      setDSTOffset(chipClusterPtr, callback, DSTOffset, null);
+      setDSTOffset(callback, DSTOffset, 0);
     }
 
     public void setDSTOffset(DefaultClusterCallback callback, ArrayList<ChipStructs.TimeSynchronizationClusterDSTOffsetStruct> DSTOffset, int timedInvokeTimeoutMs) {
-      setDSTOffset(chipClusterPtr, callback, DSTOffset, timedInvokeTimeoutMs);
+      final long commandId = 4L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long DSTOffsetFieldID = 0L;
+      BaseTLVType DSTOffsettlvValue = ArrayType.generateArrayType(DSTOffset, (elementDSTOffset) -> elementDSTOffset.encodeTlv());
+      elements.add(new StructElement(DSTOffsetFieldID, DSTOffsettlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void setDefaultNTP(DefaultClusterCallback callback, @Nullable String defaultNTP) {
-      setDefaultNTP(chipClusterPtr, callback, defaultNTP, null);
+      setDefaultNTP(callback, defaultNTP, 0);
     }
 
     public void setDefaultNTP(DefaultClusterCallback callback, @Nullable String defaultNTP, int timedInvokeTimeoutMs) {
-      setDefaultNTP(chipClusterPtr, callback, defaultNTP, timedInvokeTimeoutMs);
-    }
-
-    private native void setUTCTime(long chipClusterPtr, DefaultClusterCallback callback, Long UTCTime, Integer granularity, Optional<Integer> timeSource, @Nullable Integer timedInvokeTimeoutMs);
+      final long commandId = 5L;
 
-    private native void setTrustedTimeSource(long chipClusterPtr, DefaultClusterCallback callback, @Nullable ChipStructs.TimeSynchronizationClusterFabricScopedTrustedTimeSourceStruct trustedTimeSource, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long defaultNTPFieldID = 0L;
+      BaseTLVType defaultNTPtlvValue = defaultNTP != null ? new StringType(defaultNTP) : new NullType();
+      elements.add(new StructElement(defaultNTPFieldID, defaultNTPtlvValue));
 
-    private native void setTimeZone(long chipClusterPtr, SetTimeZoneResponseCallback callback, ArrayList<ChipStructs.TimeSynchronizationClusterTimeZoneStruct> timeZone, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void setDSTOffset(long chipClusterPtr, DefaultClusterCallback callback, ArrayList<ChipStructs.TimeSynchronizationClusterDSTOffsetStruct> DSTOffset, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void setDefaultNTP(long chipClusterPtr, DefaultClusterCallback callback, @Nullable String defaultNTP, @Nullable Integer timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface SetTimeZoneResponseCallback {
+    public interface SetTimeZoneResponseCallback extends BaseClusterCallback {
       void onSuccess(Boolean DSTOffsetRequired);
-      void onError(Exception error);
     }
 
-    public interface UTCTimeAttributeCallback {
+    public interface UTCTimeAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface TrustedTimeSourceAttributeCallback {
+    public interface TrustedTimeSourceAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable ChipStructs.TimeSynchronizationClusterTrustedTimeSourceStruct value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface DefaultNTPAttributeCallback {
+    public interface DefaultNTPAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable String value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface TimeZoneAttributeCallback {
+    public interface TimeZoneAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.TimeSynchronizationClusterTimeZoneStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface DSTOffsetAttributeCallback {
+    public interface DSTOffsetAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.TimeSynchronizationClusterDSTOffsetStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface LocalTimeAttributeCallback {
+    public interface LocalTimeAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readUTCTimeAttribute(
         UTCTimeAttributeCallback callback) {
-        readUTCTimeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, U_T_C_TIME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, U_T_C_TIME_ATTRIBUTE_ID, true);
     }
 
     public void subscribeUTCTimeAttribute(
         UTCTimeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUTCTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, U_T_C_TIME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, U_T_C_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGranularityAttribute(
         IntegerAttributeCallback callback) {
-        readGranularityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GRANULARITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GRANULARITY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGranularityAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGranularityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GRANULARITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GRANULARITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTimeSourceAttribute(
         IntegerAttributeCallback callback) {
-        readTimeSourceAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TIME_SOURCE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TIME_SOURCE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTimeSourceAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTimeSourceAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TIME_SOURCE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TIME_SOURCE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTrustedTimeSourceAttribute(
         TrustedTimeSourceAttributeCallback callback) {
-        readTrustedTimeSourceAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TRUSTED_TIME_SOURCE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable ChipStructs.TimeSynchronizationClusterTrustedTimeSourceStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TRUSTED_TIME_SOURCE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTrustedTimeSourceAttribute(
         TrustedTimeSourceAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTrustedTimeSourceAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TRUSTED_TIME_SOURCE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable ChipStructs.TimeSynchronizationClusterTrustedTimeSourceStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TRUSTED_TIME_SOURCE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDefaultNTPAttribute(
         DefaultNTPAttributeCallback callback) {
-        readDefaultNTPAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DEFAULT_N_T_P_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DEFAULT_N_T_P_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDefaultNTPAttribute(
         DefaultNTPAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDefaultNTPAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DEFAULT_N_T_P_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DEFAULT_N_T_P_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTimeZoneAttribute(
         TimeZoneAttributeCallback callback) {
-        readTimeZoneAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TIME_ZONE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.TimeSynchronizationClusterTimeZoneStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TIME_ZONE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTimeZoneAttribute(
         TimeZoneAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTimeZoneAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TIME_ZONE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.TimeSynchronizationClusterTimeZoneStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TIME_ZONE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDSTOffsetAttribute(
         DSTOffsetAttributeCallback callback) {
-        readDSTOffsetAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, D_S_T_OFFSET_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.TimeSynchronizationClusterDSTOffsetStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, D_S_T_OFFSET_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDSTOffsetAttribute(
         DSTOffsetAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDSTOffsetAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, D_S_T_OFFSET_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.TimeSynchronizationClusterDSTOffsetStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, D_S_T_OFFSET_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLocalTimeAttribute(
         LocalTimeAttributeCallback callback) {
-        readLocalTimeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOCAL_TIME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LOCAL_TIME_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLocalTimeAttribute(
         LocalTimeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLocalTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOCAL_TIME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LOCAL_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTimeZoneDatabaseAttribute(
         IntegerAttributeCallback callback) {
-        readTimeZoneDatabaseAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TIME_ZONE_DATABASE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TIME_ZONE_DATABASE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTimeZoneDatabaseAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTimeZoneDatabaseAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TIME_ZONE_DATABASE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TIME_ZONE_DATABASE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readNTPServerAvailableAttribute(
         BooleanAttributeCallback callback) {
-        readNTPServerAvailableAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, N_T_P_SERVER_AVAILABLE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, N_T_P_SERVER_AVAILABLE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeNTPServerAvailableAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNTPServerAvailableAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, N_T_P_SERVER_AVAILABLE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, N_T_P_SERVER_AVAILABLE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTimeZoneListMaxSizeAttribute(
         IntegerAttributeCallback callback) {
-        readTimeZoneListMaxSizeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TIME_ZONE_LIST_MAX_SIZE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TIME_ZONE_LIST_MAX_SIZE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTimeZoneListMaxSizeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTimeZoneListMaxSizeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TIME_ZONE_LIST_MAX_SIZE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TIME_ZONE_LIST_MAX_SIZE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDSTOffsetListMaxSizeAttribute(
         IntegerAttributeCallback callback) {
-        readDSTOffsetListMaxSizeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, D_S_T_OFFSET_LIST_MAX_SIZE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, D_S_T_OFFSET_LIST_MAX_SIZE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDSTOffsetListMaxSizeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDSTOffsetListMaxSizeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, D_S_T_OFFSET_LIST_MAX_SIZE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, D_S_T_OFFSET_LIST_MAX_SIZE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSupportsDNSResolveAttribute(
         BooleanAttributeCallback callback) {
-        readSupportsDNSResolveAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTS_D_N_S_RESOLVE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SUPPORTS_D_N_S_RESOLVE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSupportsDNSResolveAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSupportsDNSResolveAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTS_D_N_S_RESOLVE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SUPPORTS_D_N_S_RESOLVE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readUTCTimeAttribute(long chipClusterPtr, UTCTimeAttributeCallback callback);
-
-    private native void subscribeUTCTimeAttribute(long chipClusterPtr, UTCTimeAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGranularityAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeGranularityAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readTimeSourceAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeTimeSourceAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readTrustedTimeSourceAttribute(long chipClusterPtr, TrustedTimeSourceAttributeCallback callback);
-
-    private native void subscribeTrustedTimeSourceAttribute(long chipClusterPtr, TrustedTimeSourceAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readDefaultNTPAttribute(long chipClusterPtr, DefaultNTPAttributeCallback callback);
-
-    private native void subscribeDefaultNTPAttribute(long chipClusterPtr, DefaultNTPAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readTimeZoneAttribute(long chipClusterPtr, TimeZoneAttributeCallback callback);
-
-    private native void subscribeTimeZoneAttribute(long chipClusterPtr, TimeZoneAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readDSTOffsetAttribute(long chipClusterPtr, DSTOffsetAttributeCallback callback);
-
-    private native void subscribeDSTOffsetAttribute(long chipClusterPtr, DSTOffsetAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLocalTimeAttribute(long chipClusterPtr, LocalTimeAttributeCallback callback);
-
-    private native void subscribeLocalTimeAttribute(long chipClusterPtr, LocalTimeAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readTimeZoneDatabaseAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeTimeZoneDatabaseAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readNTPServerAvailableAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
-
-    private native void subscribeNTPServerAvailableAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readTimeZoneListMaxSizeAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeTimeZoneListMaxSizeAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readDSTOffsetListMaxSizeAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeDSTOffsetListMaxSizeAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSupportsDNSResolveAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
-
-    private native void subscribeSupportsDNSResolveAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class BridgedDeviceBasicInformationCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 57L;
 
+    private static final long VENDOR_NAME_ATTRIBUTE_ID = 1L;
+    private static final long VENDOR_I_D_ATTRIBUTE_ID = 2L;
+    private static final long PRODUCT_NAME_ATTRIBUTE_ID = 3L;
+    private static final long NODE_LABEL_ATTRIBUTE_ID = 5L;
+    private static final long HARDWARE_VERSION_ATTRIBUTE_ID = 7L;
+    private static final long HARDWARE_VERSION_STRING_ATTRIBUTE_ID = 8L;
+    private static final long SOFTWARE_VERSION_ATTRIBUTE_ID = 9L;
+    private static final long SOFTWARE_VERSION_STRING_ATTRIBUTE_ID = 10L;
+    private static final long MANUFACTURING_DATE_ATTRIBUTE_ID = 11L;
+    private static final long PART_NUMBER_ATTRIBUTE_ID = 12L;
+    private static final long PRODUCT_U_R_L_ATTRIBUTE_ID = 13L;
+    private static final long PRODUCT_LABEL_ATTRIBUTE_ID = 14L;
+    private static final long SERIAL_NUMBER_ATTRIBUTE_ID = 15L;
+    private static final long REACHABLE_ATTRIBUTE_ID = 17L;
+    private static final long UNIQUE_I_D_ATTRIBUTE_ID = 18L;
+    private static final long PRODUCT_APPEARANCE_ATTRIBUTE_ID = 20L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public BridgedDeviceBasicInformationCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface ProductAppearanceAttributeCallback {
+    public interface ProductAppearanceAttributeCallback extends BaseAttributeCallback {
       void onSuccess(ChipStructs.BridgedDeviceBasicInformationClusterProductAppearanceStruct value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readVendorNameAttribute(
         CharStringAttributeCallback callback) {
-        readVendorNameAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, VENDOR_NAME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, VENDOR_NAME_ATTRIBUTE_ID, true);
     }
 
     public void subscribeVendorNameAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeVendorNameAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, VENDOR_NAME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, VENDOR_NAME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readVendorIDAttribute(
         IntegerAttributeCallback callback) {
-        readVendorIDAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, VENDOR_I_D_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, VENDOR_I_D_ATTRIBUTE_ID, true);
     }
 
     public void subscribeVendorIDAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeVendorIDAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, VENDOR_I_D_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, VENDOR_I_D_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readProductNameAttribute(
         CharStringAttributeCallback callback) {
-        readProductNameAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRODUCT_NAME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRODUCT_NAME_ATTRIBUTE_ID, true);
     }
 
     public void subscribeProductNameAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeProductNameAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRODUCT_NAME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRODUCT_NAME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readNodeLabelAttribute(
         CharStringAttributeCallback callback) {
-        readNodeLabelAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NODE_LABEL_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NODE_LABEL_ATTRIBUTE_ID, true);
     }
 
     public void writeNodeLabelAttribute(DefaultClusterCallback callback, String value) {
-        writeNodeLabelAttribute(chipClusterPtr, callback, value, null);
+      writeNodeLabelAttribute(callback, value, 0);
     }
 
     public void writeNodeLabelAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) {
-        writeNodeLabelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new StringType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NODE_LABEL_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeNodeLabelAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNodeLabelAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NODE_LABEL_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NODE_LABEL_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readHardwareVersionAttribute(
         IntegerAttributeCallback callback) {
-        readHardwareVersionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, HARDWARE_VERSION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, HARDWARE_VERSION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeHardwareVersionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeHardwareVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, HARDWARE_VERSION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, HARDWARE_VERSION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readHardwareVersionStringAttribute(
         CharStringAttributeCallback callback) {
-        readHardwareVersionStringAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, HARDWARE_VERSION_STRING_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, HARDWARE_VERSION_STRING_ATTRIBUTE_ID, true);
     }
 
     public void subscribeHardwareVersionStringAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeHardwareVersionStringAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, HARDWARE_VERSION_STRING_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, HARDWARE_VERSION_STRING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSoftwareVersionAttribute(
         LongAttributeCallback callback) {
-        readSoftwareVersionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SOFTWARE_VERSION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SOFTWARE_VERSION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSoftwareVersionAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSoftwareVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SOFTWARE_VERSION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SOFTWARE_VERSION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSoftwareVersionStringAttribute(
         CharStringAttributeCallback callback) {
-        readSoftwareVersionStringAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SOFTWARE_VERSION_STRING_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SOFTWARE_VERSION_STRING_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSoftwareVersionStringAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSoftwareVersionStringAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SOFTWARE_VERSION_STRING_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SOFTWARE_VERSION_STRING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readManufacturingDateAttribute(
         CharStringAttributeCallback callback) {
-        readManufacturingDateAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MANUFACTURING_DATE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MANUFACTURING_DATE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeManufacturingDateAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeManufacturingDateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MANUFACTURING_DATE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MANUFACTURING_DATE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPartNumberAttribute(
         CharStringAttributeCallback callback) {
-        readPartNumberAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PART_NUMBER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PART_NUMBER_ATTRIBUTE_ID, true);
     }
 
     public void subscribePartNumberAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePartNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PART_NUMBER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PART_NUMBER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readProductURLAttribute(
         CharStringAttributeCallback callback) {
-        readProductURLAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRODUCT_U_R_L_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRODUCT_U_R_L_ATTRIBUTE_ID, true);
     }
 
     public void subscribeProductURLAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeProductURLAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRODUCT_U_R_L_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRODUCT_U_R_L_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readProductLabelAttribute(
         CharStringAttributeCallback callback) {
-        readProductLabelAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRODUCT_LABEL_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRODUCT_LABEL_ATTRIBUTE_ID, true);
     }
 
     public void subscribeProductLabelAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeProductLabelAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRODUCT_LABEL_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRODUCT_LABEL_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSerialNumberAttribute(
         CharStringAttributeCallback callback) {
-        readSerialNumberAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SERIAL_NUMBER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SERIAL_NUMBER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSerialNumberAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSerialNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SERIAL_NUMBER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SERIAL_NUMBER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readReachableAttribute(
         BooleanAttributeCallback callback) {
-        readReachableAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REACHABLE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, REACHABLE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeReachableAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeReachableAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REACHABLE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, REACHABLE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUniqueIDAttribute(
         CharStringAttributeCallback callback) {
-        readUniqueIDAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNIQUE_I_D_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UNIQUE_I_D_ATTRIBUTE_ID, true);
     }
 
     public void subscribeUniqueIDAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUniqueIDAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNIQUE_I_D_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UNIQUE_I_D_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readProductAppearanceAttribute(
         ProductAppearanceAttributeCallback callback) {
-        readProductAppearanceAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRODUCT_APPEARANCE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            ChipStructs.BridgedDeviceBasicInformationClusterProductAppearanceStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRODUCT_APPEARANCE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeProductAppearanceAttribute(
         ProductAppearanceAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeProductAppearanceAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRODUCT_APPEARANCE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            ChipStructs.BridgedDeviceBasicInformationClusterProductAppearanceStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRODUCT_APPEARANCE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readProductNameAttribute(long chipClusterPtr, CharStringAttributeCallback callback);
-
-    private native void subscribeProductNameAttribute(long chipClusterPtr, CharStringAttributeCallback 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 readHardwareVersionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeHardwareVersionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    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 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 readProductAppearanceAttribute(long chipClusterPtr, ProductAppearanceAttributeCallback callback);
-
-    private native void subscribeProductAppearanceAttribute(long chipClusterPtr, ProductAppearanceAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class SwitchCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 59L;
 
+    private static final long NUMBER_OF_POSITIONS_ATTRIBUTE_ID = 0L;
+    private static final long CURRENT_POSITION_ATTRIBUTE_ID = 1L;
+    private static final long MULTI_PRESS_MAX_ATTRIBUTE_ID = 2L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public SwitchCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readNumberOfPositionsAttribute(
         IntegerAttributeCallback callback) {
-        readNumberOfPositionsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_POSITIONS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NUMBER_OF_POSITIONS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeNumberOfPositionsAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNumberOfPositionsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_POSITIONS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NUMBER_OF_POSITIONS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentPositionAttribute(
         IntegerAttributeCallback callback) {
-        readCurrentPositionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_POSITION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_POSITION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentPositionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentPositionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_POSITION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_POSITION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMultiPressMaxAttribute(
         IntegerAttributeCallback callback) {
-        readMultiPressMaxAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MULTI_PRESS_MAX_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MULTI_PRESS_MAX_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMultiPressMaxAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMultiPressMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MULTI_PRESS_MAX_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MULTI_PRESS_MAX_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
+  }
 
-    private native void readNumberOfPositionsAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+  public static class AdministratorCommissioningCluster extends BaseChipCluster {
+    public static final long CLUSTER_ID = 60L;
 
-    private native void subscribeNumberOfPositionsAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    private static final long WINDOW_STATUS_ATTRIBUTE_ID = 0L;
+    private static final long ADMIN_FABRIC_INDEX_ATTRIBUTE_ID = 1L;
+    private static final long ADMIN_VENDOR_ID_ATTRIBUTE_ID = 2L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
 
-    private native void readCurrentPositionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public AdministratorCommissioningCluster(long devicePtr, int endpointId) {
+      super(devicePtr, endpointId, CLUSTER_ID);
+    }
 
-    private native void subscribeCurrentPositionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    @Override
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    private native void readMultiPressMaxAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
 
-    private native void subscribeMultiPressMaxAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void openCommissioningWindow(DefaultClusterCallback callback, Integer commissioningTimeout, byte[] PAKEPasscodeVerifier, Integer discriminator, Long iterations, byte[] salt, int timedInvokeTimeoutMs) {
+      final long commandId = 0L;
 
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long commissioningTimeoutFieldID = 0L;
+      BaseTLVType commissioningTimeouttlvValue = new UIntType(commissioningTimeout);
+      elements.add(new StructElement(commissioningTimeoutFieldID, commissioningTimeouttlvValue));
 
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      final long PAKEPasscodeVerifierFieldID = 1L;
+      BaseTLVType PAKEPasscodeVerifiertlvValue = new ByteArrayType(PAKEPasscodeVerifier);
+      elements.add(new StructElement(PAKEPasscodeVerifierFieldID, PAKEPasscodeVerifiertlvValue));
 
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
+      final long discriminatorFieldID = 2L;
+      BaseTLVType discriminatortlvValue = new UIntType(discriminator);
+      elements.add(new StructElement(discriminatorFieldID, discriminatortlvValue));
 
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      final long iterationsFieldID = 3L;
+      BaseTLVType iterationstlvValue = new UIntType(iterations);
+      elements.add(new StructElement(iterationsFieldID, iterationstlvValue));
 
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
+      final long saltFieldID = 4L;
+      BaseTLVType salttlvValue = new ByteArrayType(salt);
+      elements.add(new StructElement(saltFieldID, salttlvValue));
 
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
 
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
+    public void openBasicCommissioningWindow(DefaultClusterCallback callback, Integer commissioningTimeout, int timedInvokeTimeoutMs) {
+      final long commandId = 1L;
 
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long commissioningTimeoutFieldID = 0L;
+      BaseTLVType commissioningTimeouttlvValue = new UIntType(commissioningTimeout);
+      elements.add(new StructElement(commissioningTimeoutFieldID, commissioningTimeouttlvValue));
 
-    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 AdministratorCommissioningCluster extends BaseChipCluster {
-    public static final long CLUSTER_ID = 60L;
-
-    public AdministratorCommissioningCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
-    }
-
-    @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
-
-
-    public void openCommissioningWindow(DefaultClusterCallback callback, Integer commissioningTimeout, byte[] PAKEPasscodeVerifier, Integer discriminator, Long iterations, byte[] salt, int timedInvokeTimeoutMs) {
-      openCommissioningWindow(chipClusterPtr, callback, commissioningTimeout, PAKEPasscodeVerifier, discriminator, iterations, salt, timedInvokeTimeoutMs);
-    }
-
-
-    public void openBasicCommissioningWindow(DefaultClusterCallback callback, Integer commissioningTimeout, int timedInvokeTimeoutMs) {
-      openBasicCommissioningWindow(chipClusterPtr, callback, commissioningTimeout, timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
 
     public void revokeCommissioning(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      revokeCommissioning(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
-
-    private native void openCommissioningWindow(long chipClusterPtr, DefaultClusterCallback callback, Integer commissioningTimeout, byte[] PAKEPasscodeVerifier, Integer discriminator, Long iterations, byte[] salt, @Nullable Integer timedInvokeTimeoutMs);
+      final long commandId = 2L;
 
-    private native void openBasicCommissioningWindow(long chipClusterPtr, DefaultClusterCallback callback, Integer commissioningTimeout, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void revokeCommissioning(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface AdminFabricIndexAttributeCallback {
+    public interface AdminFabricIndexAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AdminVendorIdAttributeCallback {
+    public interface AdminVendorIdAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readWindowStatusAttribute(
         IntegerAttributeCallback callback) {
-        readWindowStatusAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WINDOW_STATUS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, WINDOW_STATUS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeWindowStatusAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeWindowStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WINDOW_STATUS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, WINDOW_STATUS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAdminFabricIndexAttribute(
         AdminFabricIndexAttributeCallback callback) {
-        readAdminFabricIndexAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ADMIN_FABRIC_INDEX_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ADMIN_FABRIC_INDEX_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAdminFabricIndexAttribute(
         AdminFabricIndexAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAdminFabricIndexAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ADMIN_FABRIC_INDEX_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ADMIN_FABRIC_INDEX_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAdminVendorIdAttribute(
         AdminVendorIdAttributeCallback callback) {
-        readAdminVendorIdAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ADMIN_VENDOR_ID_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ADMIN_VENDOR_ID_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAdminVendorIdAttribute(
         AdminVendorIdAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAdminVendorIdAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ADMIN_VENDOR_ID_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ADMIN_VENDOR_ID_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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, AdminVendorIdAttributeCallback callback);
-
-    private native void subscribeAdminVendorIdAttribute(long chipClusterPtr, AdminVendorIdAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class OperationalCredentialsCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 62L;
 
+    private static final long N_O_CS_ATTRIBUTE_ID = 0L;
+    private static final long FABRICS_ATTRIBUTE_ID = 1L;
+    private static final long SUPPORTED_FABRICS_ATTRIBUTE_ID = 2L;
+    private static final long COMMISSIONED_FABRICS_ATTRIBUTE_ID = 3L;
+    private static final long TRUSTED_ROOT_CERTIFICATES_ATTRIBUTE_ID = 4L;
+    private static final long CURRENT_FABRIC_INDEX_ATTRIBUTE_ID = 5L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public OperationalCredentialsCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void attestationRequest(AttestationResponseCallback callback, byte[] attestationNonce) {
-      attestationRequest(chipClusterPtr, callback, attestationNonce, null);
+      attestationRequest(callback, attestationNonce, 0);
     }
 
     public void attestationRequest(AttestationResponseCallback callback, byte[] attestationNonce, int timedInvokeTimeoutMs) {
-      attestationRequest(chipClusterPtr, callback, attestationNonce, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long attestationNonceFieldID = 0L;
+      BaseTLVType attestationNoncetlvValue = new ByteArrayType(attestationNonce);
+      elements.add(new StructElement(attestationNonceFieldID, attestationNoncetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long attestationElementsFieldID = 0L;
+          byte[] attestationElements = null;
+          final long attestationSignatureFieldID = 1L;
+          byte[] attestationSignature = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == attestationElementsFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+                ByteArrayType castingValue = element.value(ByteArrayType.class);
+                attestationElements = castingValue.value(byte[].class);
+              }
+            } else if (element.contextTagNum() == attestationSignatureFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+                ByteArrayType castingValue = element.value(ByteArrayType.class);
+                attestationSignature = castingValue.value(byte[].class);
+              }
+            }
+          }
+          callback.onSuccess(attestationElements, attestationSignature);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void certificateChainRequest(CertificateChainResponseCallback callback, Integer certificateType) {
-      certificateChainRequest(chipClusterPtr, callback, certificateType, null);
+      certificateChainRequest(callback, certificateType, 0);
     }
 
     public void certificateChainRequest(CertificateChainResponseCallback callback, Integer certificateType, int timedInvokeTimeoutMs) {
-      certificateChainRequest(chipClusterPtr, callback, certificateType, timedInvokeTimeoutMs);
+      final long commandId = 2L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long certificateTypeFieldID = 0L;
+      BaseTLVType certificateTypetlvValue = new UIntType(certificateType);
+      elements.add(new StructElement(certificateTypeFieldID, certificateTypetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long certificateFieldID = 0L;
+          byte[] certificate = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == certificateFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+                ByteArrayType castingValue = element.value(ByteArrayType.class);
+                certificate = castingValue.value(byte[].class);
+              }
+            }
+          }
+          callback.onSuccess(certificate);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void CSRRequest(CSRResponseCallback callback, byte[] CSRNonce, Optional<Boolean> isForUpdateNOC) {
-      CSRRequest(chipClusterPtr, callback, CSRNonce, isForUpdateNOC, null);
+      CSRRequest(callback, CSRNonce, isForUpdateNOC, 0);
     }
 
     public void CSRRequest(CSRResponseCallback callback, byte[] CSRNonce, Optional<Boolean> isForUpdateNOC, int timedInvokeTimeoutMs) {
-      CSRRequest(chipClusterPtr, callback, CSRNonce, isForUpdateNOC, timedInvokeTimeoutMs);
+      final long commandId = 4L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long CSRNonceFieldID = 0L;
+      BaseTLVType CSRNoncetlvValue = new ByteArrayType(CSRNonce);
+      elements.add(new StructElement(CSRNonceFieldID, CSRNoncetlvValue));
+
+      final long isForUpdateNOCFieldID = 1L;
+      BaseTLVType isForUpdateNOCtlvValue = isForUpdateNOC.<BaseTLVType>map((nonOptionalisForUpdateNOC) -> new BooleanType(nonOptionalisForUpdateNOC)).orElse(new EmptyType());
+      elements.add(new StructElement(isForUpdateNOCFieldID, isForUpdateNOCtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long NOCSRElementsFieldID = 0L;
+          byte[] NOCSRElements = null;
+          final long attestationSignatureFieldID = 1L;
+          byte[] attestationSignature = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == NOCSRElementsFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+                ByteArrayType castingValue = element.value(ByteArrayType.class);
+                NOCSRElements = castingValue.value(byte[].class);
+              }
+            } else if (element.contextTagNum() == attestationSignatureFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+                ByteArrayType castingValue = element.value(ByteArrayType.class);
+                attestationSignature = castingValue.value(byte[].class);
+              }
+            }
+          }
+          callback.onSuccess(NOCSRElements, attestationSignature);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void addNOC(NOCResponseCallback callback, byte[] NOCValue, Optional<byte[]> ICACValue, byte[] IPKValue, Long caseAdminSubject, Integer adminVendorId) {
-      addNOC(chipClusterPtr, callback, NOCValue, ICACValue, IPKValue, caseAdminSubject, adminVendorId, null);
+      addNOC(callback, NOCValue, ICACValue, IPKValue, caseAdminSubject, adminVendorId, 0);
     }
 
     public void addNOC(NOCResponseCallback callback, byte[] NOCValue, Optional<byte[]> ICACValue, byte[] IPKValue, Long caseAdminSubject, Integer adminVendorId, int timedInvokeTimeoutMs) {
-      addNOC(chipClusterPtr, callback, NOCValue, ICACValue, IPKValue, caseAdminSubject, adminVendorId, timedInvokeTimeoutMs);
+      final long commandId = 6L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long NOCValueFieldID = 0L;
+      BaseTLVType NOCValuetlvValue = new ByteArrayType(NOCValue);
+      elements.add(new StructElement(NOCValueFieldID, NOCValuetlvValue));
+
+      final long ICACValueFieldID = 1L;
+      BaseTLVType ICACValuetlvValue = ICACValue.<BaseTLVType>map((nonOptionalICACValue) -> new ByteArrayType(nonOptionalICACValue)).orElse(new EmptyType());
+      elements.add(new StructElement(ICACValueFieldID, ICACValuetlvValue));
+
+      final long IPKValueFieldID = 2L;
+      BaseTLVType IPKValuetlvValue = new ByteArrayType(IPKValue);
+      elements.add(new StructElement(IPKValueFieldID, IPKValuetlvValue));
+
+      final long caseAdminSubjectFieldID = 3L;
+      BaseTLVType caseAdminSubjecttlvValue = new UIntType(caseAdminSubject);
+      elements.add(new StructElement(caseAdminSubjectFieldID, caseAdminSubjecttlvValue));
+
+      final long adminVendorIdFieldID = 4L;
+      BaseTLVType adminVendorIdtlvValue = new UIntType(adminVendorId);
+      elements.add(new StructElement(adminVendorIdFieldID, adminVendorIdtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusCodeFieldID = 0L;
+          Integer statusCode = null;
+          final long fabricIndexFieldID = 1L;
+          Optional<Integer> fabricIndex = Optional.empty();
+          final long debugTextFieldID = 2L;
+          Optional<String> debugText = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusCodeFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                statusCode = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == fabricIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                fabricIndex = Optional.of(castingValue.value(Integer.class));
+              }
+            } else if (element.contextTagNum() == debugTextFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                debugText = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(statusCode, fabricIndex, debugText);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void updateNOC(NOCResponseCallback callback, byte[] NOCValue, Optional<byte[]> ICACValue) {
-      updateNOC(chipClusterPtr, callback, NOCValue, ICACValue, null);
+      updateNOC(callback, NOCValue, ICACValue, 0);
     }
 
     public void updateNOC(NOCResponseCallback callback, byte[] NOCValue, Optional<byte[]> ICACValue, int timedInvokeTimeoutMs) {
-      updateNOC(chipClusterPtr, callback, NOCValue, ICACValue, timedInvokeTimeoutMs);
+      final long commandId = 7L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long NOCValueFieldID = 0L;
+      BaseTLVType NOCValuetlvValue = new ByteArrayType(NOCValue);
+      elements.add(new StructElement(NOCValueFieldID, NOCValuetlvValue));
+
+      final long ICACValueFieldID = 1L;
+      BaseTLVType ICACValuetlvValue = ICACValue.<BaseTLVType>map((nonOptionalICACValue) -> new ByteArrayType(nonOptionalICACValue)).orElse(new EmptyType());
+      elements.add(new StructElement(ICACValueFieldID, ICACValuetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusCodeFieldID = 0L;
+          Integer statusCode = null;
+          final long fabricIndexFieldID = 1L;
+          Optional<Integer> fabricIndex = Optional.empty();
+          final long debugTextFieldID = 2L;
+          Optional<String> debugText = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusCodeFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                statusCode = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == fabricIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                fabricIndex = Optional.of(castingValue.value(Integer.class));
+              }
+            } else if (element.contextTagNum() == debugTextFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                debugText = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(statusCode, fabricIndex, debugText);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void updateFabricLabel(NOCResponseCallback callback, String label) {
-      updateFabricLabel(chipClusterPtr, callback, label, null);
+      updateFabricLabel(callback, label, 0);
     }
 
     public void updateFabricLabel(NOCResponseCallback callback, String label, int timedInvokeTimeoutMs) {
-      updateFabricLabel(chipClusterPtr, callback, label, timedInvokeTimeoutMs);
+      final long commandId = 9L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long labelFieldID = 0L;
+      BaseTLVType labeltlvValue = new StringType(label);
+      elements.add(new StructElement(labelFieldID, labeltlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusCodeFieldID = 0L;
+          Integer statusCode = null;
+          final long fabricIndexFieldID = 1L;
+          Optional<Integer> fabricIndex = Optional.empty();
+          final long debugTextFieldID = 2L;
+          Optional<String> debugText = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusCodeFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                statusCode = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == fabricIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                fabricIndex = Optional.of(castingValue.value(Integer.class));
+              }
+            } else if (element.contextTagNum() == debugTextFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                debugText = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(statusCode, fabricIndex, debugText);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void removeFabric(NOCResponseCallback callback, Integer fabricIndex) {
-      removeFabric(chipClusterPtr, callback, fabricIndex, null);
+      removeFabric(callback, fabricIndex, 0);
     }
 
     public void removeFabric(NOCResponseCallback callback, Integer fabricIndex, int timedInvokeTimeoutMs) {
-      removeFabric(chipClusterPtr, callback, fabricIndex, timedInvokeTimeoutMs);
+      final long commandId = 10L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long fabricIndexFieldID = 0L;
+      BaseTLVType fabricIndextlvValue = new UIntType(fabricIndex);
+      elements.add(new StructElement(fabricIndexFieldID, fabricIndextlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusCodeFieldID = 0L;
+          Integer statusCode = null;
+          final long fabricIndexFieldID = 1L;
+          Optional<Integer> fabricIndex = Optional.empty();
+          final long debugTextFieldID = 2L;
+          Optional<String> debugText = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusCodeFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                statusCode = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == fabricIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                fabricIndex = Optional.of(castingValue.value(Integer.class));
+              }
+            } else if (element.contextTagNum() == debugTextFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                debugText = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(statusCode, fabricIndex, debugText);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void addTrustedRootCertificate(DefaultClusterCallback callback, byte[] rootCACertificate) {
-      addTrustedRootCertificate(chipClusterPtr, callback, rootCACertificate, null);
+      addTrustedRootCertificate(callback, rootCACertificate, 0);
     }
 
     public void addTrustedRootCertificate(DefaultClusterCallback callback, byte[] rootCACertificate, int timedInvokeTimeoutMs) {
-      addTrustedRootCertificate(chipClusterPtr, callback, rootCACertificate, 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 CSRRequest(long chipClusterPtr, CSRResponseCallback callback, byte[] CSRNonce, Optional<Boolean> isForUpdateNOC, @Nullable Integer timedInvokeTimeoutMs);
+      final long commandId = 11L;
 
-    private native void addNOC(long chipClusterPtr, NOCResponseCallback callback, byte[] NOCValue, Optional<byte[]> ICACValue, byte[] IPKValue, Long caseAdminSubject, Integer adminVendorId, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long rootCACertificateFieldID = 0L;
+      BaseTLVType rootCACertificatetlvValue = new ByteArrayType(rootCACertificate);
+      elements.add(new StructElement(rootCACertificateFieldID, rootCACertificatetlvValue));
 
-    private native void updateNOC(long chipClusterPtr, NOCResponseCallback callback, byte[] NOCValue, Optional<byte[]> ICACValue, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void updateFabricLabel(long chipClusterPtr, NOCResponseCallback callback, String label, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void removeFabric(long chipClusterPtr, NOCResponseCallback callback, Integer fabricIndex, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void addTrustedRootCertificate(long chipClusterPtr, DefaultClusterCallback callback, byte[] rootCACertificate, @Nullable Integer timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface AttestationResponseCallback {
+    public interface AttestationResponseCallback extends BaseClusterCallback {
       void onSuccess(byte[] attestationElements, byte[] attestationSignature);
-      void onError(Exception error);
     }
 
-    public interface CertificateChainResponseCallback {
+    public interface CertificateChainResponseCallback extends BaseClusterCallback {
       void onSuccess(byte[] certificate);
-      void onError(Exception error);
     }
 
-    public interface CSRResponseCallback {
+    public interface CSRResponseCallback extends BaseClusterCallback {
       void onSuccess(byte[] NOCSRElements, byte[] attestationSignature);
-      void onError(Exception error);
     }
 
-    public interface NOCResponseCallback {
+    public interface NOCResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer statusCode, Optional<Integer> fabricIndex, Optional<String> debugText);
-      void onError(Exception error);
     }
 
-    public interface NOCsAttributeCallback {
+    public interface NOCsAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.OperationalCredentialsClusterNOCStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface FabricsAttributeCallback {
+    public interface FabricsAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.OperationalCredentialsClusterFabricDescriptorStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface TrustedRootCertificatesAttributeCallback {
+    public interface TrustedRootCertificatesAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<byte[]> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readNOCsAttribute(
         NOCsAttributeCallback callback) {
-        readNOCsAttribute(chipClusterPtr, callback, true);
+      readNOCsAttributeWithFabricFilter(callback, true);
     }
 
     public void readNOCsAttributeWithFabricFilter(
         NOCsAttributeCallback callback, boolean isFabricFiltered) {
-        readNOCsAttribute(chipClusterPtr, callback, isFabricFiltered);
-    }
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, N_O_CS_ATTRIBUTE_ID);
 
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.OperationalCredentialsClusterNOCStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, N_O_CS_ATTRIBUTE_ID, isFabricFiltered);
+    }
 
     public void subscribeNOCsAttribute(
         NOCsAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNOCsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, N_O_CS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.OperationalCredentialsClusterNOCStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, N_O_CS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFabricsAttribute(
         FabricsAttributeCallback callback) {
-        readFabricsAttribute(chipClusterPtr, callback, true);
+      readFabricsAttributeWithFabricFilter(callback, true);
     }
 
     public void readFabricsAttributeWithFabricFilter(
         FabricsAttributeCallback callback, boolean isFabricFiltered) {
-        readFabricsAttribute(chipClusterPtr, callback, isFabricFiltered);
-    }
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FABRICS_ATTRIBUTE_ID);
 
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.OperationalCredentialsClusterFabricDescriptorStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FABRICS_ATTRIBUTE_ID, isFabricFiltered);
+    }
 
     public void subscribeFabricsAttribute(
         FabricsAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFabricsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FABRICS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.OperationalCredentialsClusterFabricDescriptorStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FABRICS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSupportedFabricsAttribute(
         IntegerAttributeCallback callback) {
-        readSupportedFabricsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_FABRICS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SUPPORTED_FABRICS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSupportedFabricsAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSupportedFabricsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_FABRICS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SUPPORTED_FABRICS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCommissionedFabricsAttribute(
         IntegerAttributeCallback callback) {
-        readCommissionedFabricsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COMMISSIONED_FABRICS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COMMISSIONED_FABRICS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCommissionedFabricsAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCommissionedFabricsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COMMISSIONED_FABRICS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COMMISSIONED_FABRICS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTrustedRootCertificatesAttribute(
         TrustedRootCertificatesAttributeCallback callback) {
-        readTrustedRootCertificatesAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TRUSTED_ROOT_CERTIFICATES_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<byte[]> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TRUSTED_ROOT_CERTIFICATES_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTrustedRootCertificatesAttribute(
         TrustedRootCertificatesAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTrustedRootCertificatesAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TRUSTED_ROOT_CERTIFICATES_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<byte[]> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TRUSTED_ROOT_CERTIFICATES_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentFabricIndexAttribute(
         IntegerAttributeCallback callback) {
-        readCurrentFabricIndexAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_FABRIC_INDEX_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_FABRIC_INDEX_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentFabricIndexAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentFabricIndexAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_FABRIC_INDEX_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_FABRIC_INDEX_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readNOCsAttribute(long chipClusterPtr, NOCsAttributeCallback callback, boolean isFabricFiltered);
-
-    private native void subscribeNOCsAttribute(long chipClusterPtr, NOCsAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readFabricsAttribute(long chipClusterPtr, FabricsAttributeCallback callback, boolean isFabricFiltered);
-
-    private native void subscribeFabricsAttribute(long chipClusterPtr, FabricsAttributeCallback 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, IntegerAttributeCallback callback);
-
-    private native void subscribeCurrentFabricIndexAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class GroupKeyManagementCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 63L;
 
+    private static final long GROUP_KEY_MAP_ATTRIBUTE_ID = 0L;
+    private static final long GROUP_TABLE_ATTRIBUTE_ID = 1L;
+    private static final long MAX_GROUPS_PER_FABRIC_ATTRIBUTE_ID = 2L;
+    private static final long MAX_GROUP_KEYS_PER_FABRIC_ATTRIBUTE_ID = 3L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public GroupKeyManagementCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void keySetWrite(DefaultClusterCallback callback, ChipStructs.GroupKeyManagementClusterGroupKeySetStruct groupKeySet) {
-      keySetWrite(chipClusterPtr, callback, groupKeySet, null);
+      keySetWrite(callback, groupKeySet, 0);
     }
 
     public void keySetWrite(DefaultClusterCallback callback, ChipStructs.GroupKeyManagementClusterGroupKeySetStruct groupKeySet, int timedInvokeTimeoutMs) {
-      keySetWrite(chipClusterPtr, callback, groupKeySet, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long groupKeySetFieldID = 0L;
+      BaseTLVType groupKeySettlvValue = groupKeySet.encodeTlv();
+      elements.add(new StructElement(groupKeySetFieldID, groupKeySettlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void keySetRead(KeySetReadResponseCallback callback, Integer groupKeySetID) {
-      keySetRead(chipClusterPtr, callback, groupKeySetID, null);
+      keySetRead(callback, groupKeySetID, 0);
     }
 
     public void keySetRead(KeySetReadResponseCallback callback, Integer groupKeySetID, int timedInvokeTimeoutMs) {
-      keySetRead(chipClusterPtr, callback, groupKeySetID, timedInvokeTimeoutMs);
+      final long commandId = 1L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long groupKeySetIDFieldID = 0L;
+      BaseTLVType groupKeySetIDtlvValue = new UIntType(groupKeySetID);
+      elements.add(new StructElement(groupKeySetIDFieldID, groupKeySetIDtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long groupKeySetFieldID = 0L;
+          ChipStructs.GroupKeyManagementClusterGroupKeySetStruct groupKeySet = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == groupKeySetFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+                StructType castingValue = element.value(StructType.class);
+                groupKeySet = ChipStructs.GroupKeyManagementClusterGroupKeySetStruct.decodeTlv(castingValue);
+              }
+            }
+          }
+          callback.onSuccess(groupKeySet);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void keySetRemove(DefaultClusterCallback callback, Integer groupKeySetID) {
-      keySetRemove(chipClusterPtr, callback, groupKeySetID, null);
+      keySetRemove(callback, groupKeySetID, 0);
     }
 
     public void keySetRemove(DefaultClusterCallback callback, Integer groupKeySetID, int timedInvokeTimeoutMs) {
-      keySetRemove(chipClusterPtr, callback, groupKeySetID, timedInvokeTimeoutMs);
+      final long commandId = 3L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long groupKeySetIDFieldID = 0L;
+      BaseTLVType groupKeySetIDtlvValue = new UIntType(groupKeySetID);
+      elements.add(new StructElement(groupKeySetIDFieldID, groupKeySetIDtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void keySetReadAllIndices(KeySetReadAllIndicesResponseCallback callback) {
-      keySetReadAllIndices(chipClusterPtr, callback, null);
+      keySetReadAllIndices(callback, 0);
     }
 
     public void keySetReadAllIndices(KeySetReadAllIndicesResponseCallback callback, int timedInvokeTimeoutMs) {
-      keySetReadAllIndices(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
-
-    private native void keySetWrite(long chipClusterPtr, DefaultClusterCallback callback, ChipStructs.GroupKeyManagementClusterGroupKeySetStruct groupKeySet, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void keySetRead(long chipClusterPtr, KeySetReadResponseCallback callback, Integer groupKeySetID, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void keySetRemove(long chipClusterPtr, DefaultClusterCallback callback, Integer groupKeySetID, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void keySetReadAllIndices(long chipClusterPtr, KeySetReadAllIndicesResponseCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    public interface KeySetReadResponseCallback {
+      final long commandId = 4L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long groupKeySetIDsFieldID = 0L;
+          ArrayList<Integer> groupKeySetIDs = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == groupKeySetIDsFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+                ArrayType castingValue = element.value(ArrayType.class);
+                groupKeySetIDs = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+              }
+            }
+          }
+          callback.onSuccess(groupKeySetIDs);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface KeySetReadResponseCallback extends BaseClusterCallback {
       void onSuccess(ChipStructs.GroupKeyManagementClusterGroupKeySetStruct groupKeySet);
-      void onError(Exception error);
     }
 
-    public interface KeySetReadAllIndicesResponseCallback {
+    public interface KeySetReadAllIndicesResponseCallback extends BaseClusterCallback {
       void onSuccess(ArrayList<Integer> groupKeySetIDs);
-      void onError(Exception error);
     }
 
-    public interface GroupKeyMapAttributeCallback {
+    public interface GroupKeyMapAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.GroupKeyManagementClusterGroupKeyMapStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GroupTableAttributeCallback {
+    public interface GroupTableAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.GroupKeyManagementClusterGroupInfoMapStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readGroupKeyMapAttribute(
         GroupKeyMapAttributeCallback callback) {
-        readGroupKeyMapAttribute(chipClusterPtr, callback, true);
+      readGroupKeyMapAttributeWithFabricFilter(callback, true);
     }
 
     public void readGroupKeyMapAttributeWithFabricFilter(
         GroupKeyMapAttributeCallback callback, boolean isFabricFiltered) {
-        readGroupKeyMapAttribute(chipClusterPtr, callback, isFabricFiltered);
-    }
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GROUP_KEY_MAP_ATTRIBUTE_ID);
 
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.GroupKeyManagementClusterGroupKeyMapStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GROUP_KEY_MAP_ATTRIBUTE_ID, isFabricFiltered);
+    }
 
     public void writeGroupKeyMapAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.GroupKeyManagementClusterGroupKeyMapStruct> value) {
-        writeGroupKeyMapAttribute(chipClusterPtr, callback, value, null);
+      writeGroupKeyMapAttribute(callback, value, 0);
     }
 
     public void writeGroupKeyMapAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.GroupKeyManagementClusterGroupKeyMapStruct> value, int timedWriteTimeoutMs) {
-        writeGroupKeyMapAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = ArrayType.generateArrayType(value, (elementvalue) -> elementvalue.encodeTlv());
+      writeAttribute(new WriteAttributesCallbackImpl(callback), GROUP_KEY_MAP_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeGroupKeyMapAttribute(
         GroupKeyMapAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGroupKeyMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GROUP_KEY_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.GroupKeyManagementClusterGroupKeyMapStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GROUP_KEY_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGroupTableAttribute(
         GroupTableAttributeCallback callback) {
-        readGroupTableAttribute(chipClusterPtr, callback, true);
+      readGroupTableAttributeWithFabricFilter(callback, true);
     }
 
     public void readGroupTableAttributeWithFabricFilter(
         GroupTableAttributeCallback callback, boolean isFabricFiltered) {
-        readGroupTableAttribute(chipClusterPtr, callback, isFabricFiltered);
-    }
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GROUP_TABLE_ATTRIBUTE_ID);
 
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.GroupKeyManagementClusterGroupInfoMapStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GROUP_TABLE_ATTRIBUTE_ID, isFabricFiltered);
+    }
 
     public void subscribeGroupTableAttribute(
         GroupTableAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGroupTableAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GROUP_TABLE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.GroupKeyManagementClusterGroupInfoMapStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GROUP_TABLE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxGroupsPerFabricAttribute(
         IntegerAttributeCallback callback) {
-        readMaxGroupsPerFabricAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_GROUPS_PER_FABRIC_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_GROUPS_PER_FABRIC_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxGroupsPerFabricAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxGroupsPerFabricAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_GROUPS_PER_FABRIC_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_GROUPS_PER_FABRIC_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxGroupKeysPerFabricAttribute(
         IntegerAttributeCallback callback) {
-        readMaxGroupKeysPerFabricAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_GROUP_KEYS_PER_FABRIC_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_GROUP_KEYS_PER_FABRIC_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxGroupKeysPerFabricAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxGroupKeysPerFabricAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_GROUP_KEYS_PER_FABRIC_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_GROUP_KEYS_PER_FABRIC_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readGroupKeyMapAttribute(long chipClusterPtr, GroupKeyMapAttributeCallback callback, boolean isFabricFiltered);
-
-    private native void writeGroupKeyMapAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList<ChipStructs.GroupKeyManagementClusterGroupKeyMapStruct> value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeGroupKeyMapAttribute(long chipClusterPtr, GroupKeyMapAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGroupTableAttribute(long chipClusterPtr, GroupTableAttributeCallback callback, boolean isFabricFiltered);
-
-    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);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeMaxGroupKeysPerFabricAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class FixedLabelCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 64L;
 
+    private static final long LABEL_LIST_ATTRIBUTE_ID = 0L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public FixedLabelCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface LabelListAttributeCallback {
+    public interface LabelListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.FixedLabelClusterLabelStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readLabelListAttribute(
         LabelListAttributeCallback callback) {
-        readLabelListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LABEL_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.FixedLabelClusterLabelStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LABEL_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLabelListAttribute(
         LabelListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLabelListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LABEL_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.FixedLabelClusterLabelStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LABEL_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class UserLabelCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 65L;
 
+    private static final long LABEL_LIST_ATTRIBUTE_ID = 0L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public UserLabelCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface LabelListAttributeCallback {
+    public interface LabelListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.UserLabelClusterLabelStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readLabelListAttribute(
         LabelListAttributeCallback callback) {
-        readLabelListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LABEL_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.UserLabelClusterLabelStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LABEL_LIST_ATTRIBUTE_ID, true);
     }
 
     public void writeLabelListAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.UserLabelClusterLabelStruct> value) {
-        writeLabelListAttribute(chipClusterPtr, callback, value, null);
+      writeLabelListAttribute(callback, value, 0);
     }
 
     public void writeLabelListAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.UserLabelClusterLabelStruct> value, int timedWriteTimeoutMs) {
-        writeLabelListAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = ArrayType.generateArrayType(value, (elementvalue) -> elementvalue.encodeTlv());
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LABEL_LIST_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeLabelListAttribute(
         LabelListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLabelListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LABEL_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.UserLabelClusterLabelStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LABEL_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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<ChipStructs.UserLabelClusterLabelStruct> value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeLabelListAttribute(long chipClusterPtr, LabelListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class ProxyConfigurationCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 66L;
 
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public ProxyConfigurationCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
+  }
 
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+  public static class ProxyDiscoveryCluster extends BaseChipCluster {
+    public static final long CLUSTER_ID = 67L;
 
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
 
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+    public ProxyDiscoveryCluster(long devicePtr, int endpointId) {
+      super(devicePtr, endpointId, CLUSTER_ID);
+    }
 
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
+    @Override
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-  }
-
-  public static class ProxyDiscoveryCluster extends BaseChipCluster {
-    public static final long CLUSTER_ID = 67L;
-
-    public ProxyDiscoveryCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
-    }
-
-    @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
-
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class ProxyValidCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 68L;
 
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public ProxyValidCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class BooleanStateCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 69L;
 
+    private static final long STATE_VALUE_ATTRIBUTE_ID = 0L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public BooleanStateCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readStateValueAttribute(
         BooleanAttributeCallback callback) {
-        readStateValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STATE_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, STATE_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeStateValueAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeStateValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STATE_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, STATE_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class IcdManagementCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 70L;
 
+    private static final long IDLE_MODE_DURATION_ATTRIBUTE_ID = 0L;
+    private static final long ACTIVE_MODE_DURATION_ATTRIBUTE_ID = 1L;
+    private static final long ACTIVE_MODE_THRESHOLD_ATTRIBUTE_ID = 2L;
+    private static final long REGISTERED_CLIENTS_ATTRIBUTE_ID = 3L;
+    private static final long I_C_D_COUNTER_ATTRIBUTE_ID = 4L;
+    private static final long CLIENTS_SUPPORTED_PER_FABRIC_ATTRIBUTE_ID = 5L;
+    private static final long USER_ACTIVE_MODE_TRIGGER_HINT_ATTRIBUTE_ID = 6L;
+    private static final long USER_ACTIVE_MODE_TRIGGER_INSTRUCTION_ATTRIBUTE_ID = 7L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public IcdManagementCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void registerClient(RegisterClientResponseCallback callback, Long checkInNodeID, Long monitoredSubject, byte[] key, Optional<byte[]> verificationKey) {
-      registerClient(chipClusterPtr, callback, checkInNodeID, monitoredSubject, key, verificationKey, null);
+      registerClient(callback, checkInNodeID, monitoredSubject, key, verificationKey, 0);
     }
 
     public void registerClient(RegisterClientResponseCallback callback, Long checkInNodeID, Long monitoredSubject, byte[] key, Optional<byte[]> verificationKey, int timedInvokeTimeoutMs) {
-      registerClient(chipClusterPtr, callback, checkInNodeID, monitoredSubject, key, verificationKey, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long checkInNodeIDFieldID = 0L;
+      BaseTLVType checkInNodeIDtlvValue = new UIntType(checkInNodeID);
+      elements.add(new StructElement(checkInNodeIDFieldID, checkInNodeIDtlvValue));
+
+      final long monitoredSubjectFieldID = 1L;
+      BaseTLVType monitoredSubjecttlvValue = new UIntType(monitoredSubject);
+      elements.add(new StructElement(monitoredSubjectFieldID, monitoredSubjecttlvValue));
+
+      final long keyFieldID = 2L;
+      BaseTLVType keytlvValue = new ByteArrayType(key);
+      elements.add(new StructElement(keyFieldID, keytlvValue));
+
+      final long verificationKeyFieldID = 3L;
+      BaseTLVType verificationKeytlvValue = verificationKey.<BaseTLVType>map((nonOptionalverificationKey) -> new ByteArrayType(nonOptionalverificationKey)).orElse(new EmptyType());
+      elements.add(new StructElement(verificationKeyFieldID, verificationKeytlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long ICDCounterFieldID = 0L;
+          Long ICDCounter = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == ICDCounterFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                ICDCounter = castingValue.value(Long.class);
+              }
+            }
+          }
+          callback.onSuccess(ICDCounter);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void unregisterClient(DefaultClusterCallback callback, Long checkInNodeID, Optional<byte[]> verificationKey) {
-      unregisterClient(chipClusterPtr, callback, checkInNodeID, verificationKey, null);
+      unregisterClient(callback, checkInNodeID, verificationKey, 0);
     }
 
     public void unregisterClient(DefaultClusterCallback callback, Long checkInNodeID, Optional<byte[]> verificationKey, int timedInvokeTimeoutMs) {
-      unregisterClient(chipClusterPtr, callback, checkInNodeID, verificationKey, timedInvokeTimeoutMs);
+      final long commandId = 2L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long checkInNodeIDFieldID = 0L;
+      BaseTLVType checkInNodeIDtlvValue = new UIntType(checkInNodeID);
+      elements.add(new StructElement(checkInNodeIDFieldID, checkInNodeIDtlvValue));
+
+      final long verificationKeyFieldID = 1L;
+      BaseTLVType verificationKeytlvValue = verificationKey.<BaseTLVType>map((nonOptionalverificationKey) -> new ByteArrayType(nonOptionalverificationKey)).orElse(new EmptyType());
+      elements.add(new StructElement(verificationKeyFieldID, verificationKeytlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void stayActiveRequest(DefaultClusterCallback callback) {
-      stayActiveRequest(chipClusterPtr, callback, null);
+      stayActiveRequest(callback, 0);
     }
 
     public void stayActiveRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      stayActiveRequest(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
-
-    private native void registerClient(long chipClusterPtr, RegisterClientResponseCallback callback, Long checkInNodeID, Long monitoredSubject, byte[] key, Optional<byte[]> verificationKey, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void unregisterClient(long chipClusterPtr, DefaultClusterCallback callback, Long checkInNodeID, Optional<byte[]> verificationKey, @Nullable Integer timedInvokeTimeoutMs);
+      final long commandId = 3L;
 
-    private native void stayActiveRequest(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface RegisterClientResponseCallback {
+    public interface RegisterClientResponseCallback extends BaseClusterCallback {
       void onSuccess(Long ICDCounter);
-      void onError(Exception error);
     }
 
-    public interface RegisteredClientsAttributeCallback {
+    public interface RegisteredClientsAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.IcdManagementClusterMonitoringRegistrationStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readIdleModeDurationAttribute(
         LongAttributeCallback callback) {
-        readIdleModeDurationAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, IDLE_MODE_DURATION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, IDLE_MODE_DURATION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeIdleModeDurationAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeIdleModeDurationAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, IDLE_MODE_DURATION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, IDLE_MODE_DURATION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActiveModeDurationAttribute(
         LongAttributeCallback callback) {
-        readActiveModeDurationAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_MODE_DURATION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_MODE_DURATION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActiveModeDurationAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActiveModeDurationAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_MODE_DURATION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_MODE_DURATION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActiveModeThresholdAttribute(
         IntegerAttributeCallback callback) {
-        readActiveModeThresholdAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_MODE_THRESHOLD_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_MODE_THRESHOLD_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActiveModeThresholdAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActiveModeThresholdAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_MODE_THRESHOLD_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_MODE_THRESHOLD_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRegisteredClientsAttribute(
         RegisteredClientsAttributeCallback callback) {
-        readRegisteredClientsAttribute(chipClusterPtr, callback, true);
+      readRegisteredClientsAttributeWithFabricFilter(callback, true);
     }
 
     public void readRegisteredClientsAttributeWithFabricFilter(
         RegisteredClientsAttributeCallback callback, boolean isFabricFiltered) {
-        readRegisteredClientsAttribute(chipClusterPtr, callback, isFabricFiltered);
-    }
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REGISTERED_CLIENTS_ATTRIBUTE_ID);
 
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.IcdManagementClusterMonitoringRegistrationStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, REGISTERED_CLIENTS_ATTRIBUTE_ID, isFabricFiltered);
+    }
 
     public void subscribeRegisteredClientsAttribute(
         RegisteredClientsAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRegisteredClientsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REGISTERED_CLIENTS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.IcdManagementClusterMonitoringRegistrationStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, REGISTERED_CLIENTS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readICDCounterAttribute(
         LongAttributeCallback callback) {
-        readICDCounterAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, I_C_D_COUNTER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, I_C_D_COUNTER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeICDCounterAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeICDCounterAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, I_C_D_COUNTER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, I_C_D_COUNTER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClientsSupportedPerFabricAttribute(
         IntegerAttributeCallback callback) {
-        readClientsSupportedPerFabricAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLIENTS_SUPPORTED_PER_FABRIC_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLIENTS_SUPPORTED_PER_FABRIC_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClientsSupportedPerFabricAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClientsSupportedPerFabricAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLIENTS_SUPPORTED_PER_FABRIC_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLIENTS_SUPPORTED_PER_FABRIC_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUserActiveModeTriggerHintAttribute(
         LongAttributeCallback callback) {
-        readUserActiveModeTriggerHintAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, USER_ACTIVE_MODE_TRIGGER_HINT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, USER_ACTIVE_MODE_TRIGGER_HINT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeUserActiveModeTriggerHintAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUserActiveModeTriggerHintAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, USER_ACTIVE_MODE_TRIGGER_HINT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, USER_ACTIVE_MODE_TRIGGER_HINT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUserActiveModeTriggerInstructionAttribute(
         CharStringAttributeCallback callback) {
-        readUserActiveModeTriggerInstructionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, USER_ACTIVE_MODE_TRIGGER_INSTRUCTION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, USER_ACTIVE_MODE_TRIGGER_INSTRUCTION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeUserActiveModeTriggerInstructionAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUserActiveModeTriggerInstructionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, USER_ACTIVE_MODE_TRIGGER_INSTRUCTION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, USER_ACTIVE_MODE_TRIGGER_INSTRUCTION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readIdleModeDurationAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeIdleModeDurationAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readActiveModeDurationAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeActiveModeDurationAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readActiveModeThresholdAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeActiveModeThresholdAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRegisteredClientsAttribute(long chipClusterPtr, RegisteredClientsAttributeCallback callback, boolean isFabricFiltered);
-
-    private native void subscribeRegisteredClientsAttribute(long chipClusterPtr, RegisteredClientsAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readICDCounterAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeICDCounterAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClientsSupportedPerFabricAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClientsSupportedPerFabricAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readUserActiveModeTriggerHintAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeUserActiveModeTriggerHintAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readUserActiveModeTriggerInstructionAttribute(long chipClusterPtr, CharStringAttributeCallback callback);
-
-    private native void subscribeUserActiveModeTriggerInstructionAttribute(long chipClusterPtr, CharStringAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class ModeSelectCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 80L;
 
+    private static final long DESCRIPTION_ATTRIBUTE_ID = 0L;
+    private static final long STANDARD_NAMESPACE_ATTRIBUTE_ID = 1L;
+    private static final long SUPPORTED_MODES_ATTRIBUTE_ID = 2L;
+    private static final long CURRENT_MODE_ATTRIBUTE_ID = 3L;
+    private static final long START_UP_MODE_ATTRIBUTE_ID = 4L;
+    private static final long ON_MODE_ATTRIBUTE_ID = 5L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public ModeSelectCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void changeToMode(DefaultClusterCallback callback, Integer newMode) {
-      changeToMode(chipClusterPtr, callback, newMode, null);
+      changeToMode(callback, newMode, 0);
     }
 
     public void changeToMode(DefaultClusterCallback callback, Integer newMode, int timedInvokeTimeoutMs) {
-      changeToMode(chipClusterPtr, callback, newMode, timedInvokeTimeoutMs);
-    }
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long newModeFieldID = 0L;
+      BaseTLVType newModetlvValue = new UIntType(newMode);
+      elements.add(new StructElement(newModeFieldID, newModetlvValue));
 
-    private native void changeToMode(long chipClusterPtr, DefaultClusterCallback callback, Integer newMode, @Nullable Integer timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface StandardNamespaceAttributeCallback {
+    public interface StandardNamespaceAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface SupportedModesAttributeCallback {
+    public interface SupportedModesAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.ModeSelectClusterModeOptionStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface StartUpModeAttributeCallback {
+    public interface StartUpModeAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface OnModeAttributeCallback {
+    public interface OnModeAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readDescriptionAttribute(
         CharStringAttributeCallback callback) {
-        readDescriptionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DESCRIPTION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DESCRIPTION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDescriptionAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDescriptionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DESCRIPTION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DESCRIPTION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readStandardNamespaceAttribute(
         StandardNamespaceAttributeCallback callback) {
-        readStandardNamespaceAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STANDARD_NAMESPACE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, STANDARD_NAMESPACE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeStandardNamespaceAttribute(
         StandardNamespaceAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeStandardNamespaceAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STANDARD_NAMESPACE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, STANDARD_NAMESPACE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSupportedModesAttribute(
         SupportedModesAttributeCallback callback) {
-        readSupportedModesAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_MODES_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.ModeSelectClusterModeOptionStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SUPPORTED_MODES_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSupportedModesAttribute(
         SupportedModesAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSupportedModesAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_MODES_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.ModeSelectClusterModeOptionStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SUPPORTED_MODES_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentModeAttribute(
         IntegerAttributeCallback callback) {
-        readCurrentModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_MODE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentModeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readStartUpModeAttribute(
         StartUpModeAttributeCallback callback) {
-        readStartUpModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, START_UP_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, START_UP_MODE_ATTRIBUTE_ID, true);
     }
 
     public void writeStartUpModeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeStartUpModeAttribute(chipClusterPtr, callback, value, null);
+      writeStartUpModeAttribute(callback, value, 0);
     }
 
     public void writeStartUpModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeStartUpModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), START_UP_MODE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeStartUpModeAttribute(
         StartUpModeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeStartUpModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, START_UP_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, START_UP_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOnModeAttribute(
         OnModeAttributeCallback callback) {
-        readOnModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ON_MODE_ATTRIBUTE_ID, true);
     }
 
     public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOnModeAttribute(chipClusterPtr, callback, value, null);
+      writeOnModeAttribute(callback, value, 0);
     }
 
     public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOnModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ON_MODE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOnModeAttribute(
         OnModeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOnModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ON_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readDescriptionAttribute(long chipClusterPtr, CharStringAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeDescriptionAttribute(long chipClusterPtr, CharStringAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readStandardNamespaceAttribute(long chipClusterPtr, StandardNamespaceAttributeCallback callback);
-
-    private native void subscribeStandardNamespaceAttribute(long chipClusterPtr, StandardNamespaceAttributeCallback 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 readCurrentModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeCurrentModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readStartUpModeAttribute(long chipClusterPtr, StartUpModeAttributeCallback callback);
-
-    private native void writeStartUpModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeStartUpModeAttribute(long chipClusterPtr, StartUpModeAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readOnModeAttribute(long chipClusterPtr, OnModeAttributeCallback callback);
-
-    private native void writeOnModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeOnModeAttribute(long chipClusterPtr, OnModeAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class LaundryWasherModeCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 81L;
 
+    private static final long SUPPORTED_MODES_ATTRIBUTE_ID = 0L;
+    private static final long CURRENT_MODE_ATTRIBUTE_ID = 1L;
+    private static final long START_UP_MODE_ATTRIBUTE_ID = 2L;
+    private static final long ON_MODE_ATTRIBUTE_ID = 3L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public LaundryWasherModeCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void changeToMode(ChangeToModeResponseCallback callback, Integer newMode) {
-      changeToMode(chipClusterPtr, callback, newMode, null);
+      changeToMode(callback, newMode, 0);
     }
 
     public void changeToMode(ChangeToModeResponseCallback callback, Integer newMode, int timedInvokeTimeoutMs) {
-      changeToMode(chipClusterPtr, callback, newMode, timedInvokeTimeoutMs);
-    }
-
-    private native void changeToMode(long chipClusterPtr, ChangeToModeResponseCallback callback, Integer newMode, @Nullable Integer timedInvokeTimeoutMs);
-
-    public interface ChangeToModeResponseCallback {
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long newModeFieldID = 0L;
+      BaseTLVType newModetlvValue = new UIntType(newMode);
+      elements.add(new StructElement(newModeFieldID, newModetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long statusTextFieldID = 1L;
+          Optional<String> statusText = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == statusTextFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                statusText = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(status, statusText);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface ChangeToModeResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, Optional<String> statusText);
-      void onError(Exception error);
     }
 
-    public interface SupportedModesAttributeCallback {
+    public interface SupportedModesAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.LaundryWasherModeClusterModeOptionStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface StartUpModeAttributeCallback {
+    public interface StartUpModeAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface OnModeAttributeCallback {
+    public interface OnModeAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readSupportedModesAttribute(
         SupportedModesAttributeCallback callback) {
-        readSupportedModesAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_MODES_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.LaundryWasherModeClusterModeOptionStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SUPPORTED_MODES_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSupportedModesAttribute(
         SupportedModesAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSupportedModesAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_MODES_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.LaundryWasherModeClusterModeOptionStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SUPPORTED_MODES_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentModeAttribute(
         IntegerAttributeCallback callback) {
-        readCurrentModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_MODE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentModeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readStartUpModeAttribute(
         StartUpModeAttributeCallback callback) {
-        readStartUpModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, START_UP_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, START_UP_MODE_ATTRIBUTE_ID, true);
     }
 
     public void writeStartUpModeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeStartUpModeAttribute(chipClusterPtr, callback, value, null);
+      writeStartUpModeAttribute(callback, value, 0);
     }
 
     public void writeStartUpModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeStartUpModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), START_UP_MODE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeStartUpModeAttribute(
         StartUpModeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeStartUpModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, START_UP_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, START_UP_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOnModeAttribute(
         OnModeAttributeCallback callback) {
-        readOnModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ON_MODE_ATTRIBUTE_ID, true);
     }
 
     public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOnModeAttribute(chipClusterPtr, callback, value, null);
+      writeOnModeAttribute(callback, value, 0);
     }
 
     public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOnModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ON_MODE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOnModeAttribute(
         OnModeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOnModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ON_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
+  }
 
-    private native void readSupportedModesAttribute(long chipClusterPtr, SupportedModesAttributeCallback callback);
+  public static class RefrigeratorAndTemperatureControlledCabinetModeCluster extends BaseChipCluster {
+    public static final long CLUSTER_ID = 82L;
 
-    private native void subscribeSupportedModesAttribute(long chipClusterPtr, SupportedModesAttributeCallback callback, int minInterval, int maxInterval);
+    private static final long SUPPORTED_MODES_ATTRIBUTE_ID = 0L;
+    private static final long CURRENT_MODE_ATTRIBUTE_ID = 1L;
+    private static final long START_UP_MODE_ATTRIBUTE_ID = 2L;
+    private static final long ON_MODE_ATTRIBUTE_ID = 3L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
 
-    private native void readCurrentModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public RefrigeratorAndTemperatureControlledCabinetModeCluster(long devicePtr, int endpointId) {
+      super(devicePtr, endpointId, CLUSTER_ID);
+    }
 
-    private native void subscribeCurrentModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    @Override
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    private native void readStartUpModeAttribute(long chipClusterPtr, StartUpModeAttributeCallback callback);
+    public void changeToMode(ChangeToModeResponseCallback callback, Integer newMode) {
+      changeToMode(callback, newMode, 0);
+    }
 
-    private native void writeStartUpModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    public void changeToMode(ChangeToModeResponseCallback callback, Integer newMode, int timedInvokeTimeoutMs) {
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long newModeFieldID = 0L;
+      BaseTLVType newModetlvValue = new UIntType(newMode);
+      elements.add(new StructElement(newModeFieldID, newModetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long statusTextFieldID = 1L;
+          Optional<String> statusText = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == statusTextFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                statusText = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(status, statusText);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface ChangeToModeResponseCallback extends BaseClusterCallback {
+      void onSuccess(Integer status, Optional<String> statusText);
+    }
 
-    private native void subscribeStartUpModeAttribute(long chipClusterPtr, StartUpModeAttributeCallback callback, int minInterval, int maxInterval);
+    public interface SupportedModesAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<ChipStructs.RefrigeratorAndTemperatureControlledCabinetModeClusterModeOptionStruct> value);
+    }
 
-    private native void readOnModeAttribute(long chipClusterPtr, OnModeAttributeCallback callback);
-
-    private native void writeOnModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeOnModeAttribute(long chipClusterPtr, OnModeAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-  }
-
-  public static class RefrigeratorAndTemperatureControlledCabinetModeCluster extends BaseChipCluster {
-    public static final long CLUSTER_ID = 82L;
-
-    public RefrigeratorAndTemperatureControlledCabinetModeCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
-    }
-
-    @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
-
-    public void changeToMode(ChangeToModeResponseCallback callback, Integer newMode) {
-      changeToMode(chipClusterPtr, callback, newMode, null);
-    }
-
-    public void changeToMode(ChangeToModeResponseCallback callback, Integer newMode, int timedInvokeTimeoutMs) {
-      changeToMode(chipClusterPtr, callback, newMode, timedInvokeTimeoutMs);
-    }
-
-    private native void changeToMode(long chipClusterPtr, ChangeToModeResponseCallback callback, Integer newMode, @Nullable Integer timedInvokeTimeoutMs);
-
-    public interface ChangeToModeResponseCallback {
-      void onSuccess(Integer status, Optional<String> statusText);
-      void onError(Exception error);
-    }
-
-    public interface SupportedModesAttributeCallback {
-      void onSuccess(List<ChipStructs.RefrigeratorAndTemperatureControlledCabinetModeClusterModeOptionStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface StartUpModeAttributeCallback {
+    public interface StartUpModeAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface OnModeAttributeCallback {
+    public interface OnModeAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readSupportedModesAttribute(
         SupportedModesAttributeCallback callback) {
-        readSupportedModesAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_MODES_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.RefrigeratorAndTemperatureControlledCabinetModeClusterModeOptionStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SUPPORTED_MODES_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSupportedModesAttribute(
         SupportedModesAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSupportedModesAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_MODES_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.RefrigeratorAndTemperatureControlledCabinetModeClusterModeOptionStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SUPPORTED_MODES_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentModeAttribute(
         IntegerAttributeCallback callback) {
-        readCurrentModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_MODE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentModeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readStartUpModeAttribute(
         StartUpModeAttributeCallback callback) {
-        readStartUpModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, START_UP_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, START_UP_MODE_ATTRIBUTE_ID, true);
     }
 
     public void writeStartUpModeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeStartUpModeAttribute(chipClusterPtr, callback, value, null);
+      writeStartUpModeAttribute(callback, value, 0);
     }
 
     public void writeStartUpModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeStartUpModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), START_UP_MODE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeStartUpModeAttribute(
         StartUpModeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeStartUpModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, START_UP_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, START_UP_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOnModeAttribute(
         OnModeAttributeCallback callback) {
-        readOnModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ON_MODE_ATTRIBUTE_ID, true);
     }
 
     public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOnModeAttribute(chipClusterPtr, callback, value, null);
+      writeOnModeAttribute(callback, value, 0);
     }
 
     public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOnModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ON_MODE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOnModeAttribute(
         OnModeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOnModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ON_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readSupportedModesAttribute(long chipClusterPtr, SupportedModesAttributeCallback callback);
-
-    private native void subscribeSupportedModesAttribute(long chipClusterPtr, SupportedModesAttributeCallback 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 readStartUpModeAttribute(long chipClusterPtr, StartUpModeAttributeCallback callback);
-
-    private native void writeStartUpModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeStartUpModeAttribute(long chipClusterPtr, StartUpModeAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readOnModeAttribute(long chipClusterPtr, OnModeAttributeCallback callback);
-
-    private native void writeOnModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeOnModeAttribute(long chipClusterPtr, OnModeAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class LaundryWasherControlsCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 83L;
 
+    private static final long SPIN_SPEEDS_ATTRIBUTE_ID = 0L;
+    private static final long SPIN_SPEED_CURRENT_ATTRIBUTE_ID = 1L;
+    private static final long NUMBER_OF_RINSES_ATTRIBUTE_ID = 2L;
+    private static final long SUPPORTED_RINSES_ATTRIBUTE_ID = 3L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public LaundryWasherControlsCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface SpinSpeedsAttributeCallback {
+    public interface SpinSpeedsAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<String> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface SpinSpeedCurrentAttributeCallback {
+    public interface SpinSpeedCurrentAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface SupportedRinsesAttributeCallback {
+    public interface SupportedRinsesAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Integer> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readSpinSpeedsAttribute(
         SpinSpeedsAttributeCallback callback) {
-        readSpinSpeedsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SPIN_SPEEDS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<String> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SPIN_SPEEDS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSpinSpeedsAttribute(
         SpinSpeedsAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSpinSpeedsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SPIN_SPEEDS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<String> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SPIN_SPEEDS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSpinSpeedCurrentAttribute(
         SpinSpeedCurrentAttributeCallback callback) {
-        readSpinSpeedCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SPIN_SPEED_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SPIN_SPEED_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void writeSpinSpeedCurrentAttribute(DefaultClusterCallback callback, Integer value) {
-        writeSpinSpeedCurrentAttribute(chipClusterPtr, callback, value, null);
+      writeSpinSpeedCurrentAttribute(callback, value, 0);
     }
 
     public void writeSpinSpeedCurrentAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeSpinSpeedCurrentAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), SPIN_SPEED_CURRENT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeSpinSpeedCurrentAttribute(
         SpinSpeedCurrentAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSpinSpeedCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SPIN_SPEED_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SPIN_SPEED_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readNumberOfRinsesAttribute(
         IntegerAttributeCallback callback) {
-        readNumberOfRinsesAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_RINSES_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NUMBER_OF_RINSES_ATTRIBUTE_ID, true);
     }
 
     public void writeNumberOfRinsesAttribute(DefaultClusterCallback callback, Integer value) {
-        writeNumberOfRinsesAttribute(chipClusterPtr, callback, value, null);
+      writeNumberOfRinsesAttribute(callback, value, 0);
     }
 
     public void writeNumberOfRinsesAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeNumberOfRinsesAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NUMBER_OF_RINSES_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeNumberOfRinsesAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNumberOfRinsesAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_RINSES_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NUMBER_OF_RINSES_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSupportedRinsesAttribute(
         SupportedRinsesAttributeCallback callback) {
-        readSupportedRinsesAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_RINSES_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SUPPORTED_RINSES_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSupportedRinsesAttribute(
         SupportedRinsesAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSupportedRinsesAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_RINSES_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SUPPORTED_RINSES_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readSpinSpeedsAttribute(long chipClusterPtr, SpinSpeedsAttributeCallback callback);
-
-    private native void subscribeSpinSpeedsAttribute(long chipClusterPtr, SpinSpeedsAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSpinSpeedCurrentAttribute(long chipClusterPtr, SpinSpeedCurrentAttributeCallback callback);
-
-    private native void writeSpinSpeedCurrentAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeSpinSpeedCurrentAttribute(long chipClusterPtr, SpinSpeedCurrentAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readNumberOfRinsesAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeNumberOfRinsesAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeNumberOfRinsesAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSupportedRinsesAttribute(long chipClusterPtr, SupportedRinsesAttributeCallback callback);
-
-    private native void subscribeSupportedRinsesAttribute(long chipClusterPtr, SupportedRinsesAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class RvcRunModeCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 84L;
 
+    private static final long SUPPORTED_MODES_ATTRIBUTE_ID = 0L;
+    private static final long CURRENT_MODE_ATTRIBUTE_ID = 1L;
+    private static final long ON_MODE_ATTRIBUTE_ID = 3L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public RvcRunModeCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void changeToMode(ChangeToModeResponseCallback callback, Integer newMode) {
-      changeToMode(chipClusterPtr, callback, newMode, null);
+      changeToMode(callback, newMode, 0);
     }
 
     public void changeToMode(ChangeToModeResponseCallback callback, Integer newMode, int timedInvokeTimeoutMs) {
-      changeToMode(chipClusterPtr, callback, newMode, timedInvokeTimeoutMs);
-    }
-
-    private native void changeToMode(long chipClusterPtr, ChangeToModeResponseCallback callback, Integer newMode, @Nullable Integer timedInvokeTimeoutMs);
-
-    public interface ChangeToModeResponseCallback {
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long newModeFieldID = 0L;
+      BaseTLVType newModetlvValue = new UIntType(newMode);
+      elements.add(new StructElement(newModeFieldID, newModetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long statusTextFieldID = 1L;
+          Optional<String> statusText = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == statusTextFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                statusText = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(status, statusText);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface ChangeToModeResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, Optional<String> statusText);
-      void onError(Exception error);
     }
 
-    public interface SupportedModesAttributeCallback {
+    public interface SupportedModesAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.RvcRunModeClusterModeOptionStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface OnModeAttributeCallback {
+    public interface OnModeAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readSupportedModesAttribute(
         SupportedModesAttributeCallback callback) {
-        readSupportedModesAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_MODES_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.RvcRunModeClusterModeOptionStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SUPPORTED_MODES_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSupportedModesAttribute(
         SupportedModesAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSupportedModesAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_MODES_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.RvcRunModeClusterModeOptionStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SUPPORTED_MODES_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentModeAttribute(
         IntegerAttributeCallback callback) {
-        readCurrentModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_MODE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentModeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOnModeAttribute(
         OnModeAttributeCallback callback) {
-        readOnModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ON_MODE_ATTRIBUTE_ID, true);
     }
 
     public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOnModeAttribute(chipClusterPtr, callback, value, null);
+      writeOnModeAttribute(callback, value, 0);
     }
 
     public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOnModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ON_MODE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOnModeAttribute(
         OnModeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOnModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ON_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readSupportedModesAttribute(long chipClusterPtr, SupportedModesAttributeCallback callback);
-
-    private native void subscribeSupportedModesAttribute(long chipClusterPtr, SupportedModesAttributeCallback 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 readOnModeAttribute(long chipClusterPtr, OnModeAttributeCallback callback);
-
-    private native void writeOnModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeOnModeAttribute(long chipClusterPtr, OnModeAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    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);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class RvcCleanModeCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 85L;
 
+    private static final long SUPPORTED_MODES_ATTRIBUTE_ID = 0L;
+    private static final long CURRENT_MODE_ATTRIBUTE_ID = 1L;
+    private static final long ON_MODE_ATTRIBUTE_ID = 3L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public RvcCleanModeCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void changeToMode(ChangeToModeResponseCallback callback, Integer newMode) {
-      changeToMode(chipClusterPtr, callback, newMode, null);
+      changeToMode(callback, newMode, 0);
     }
 
     public void changeToMode(ChangeToModeResponseCallback callback, Integer newMode, int timedInvokeTimeoutMs) {
-      changeToMode(chipClusterPtr, callback, newMode, timedInvokeTimeoutMs);
-    }
-
-    private native void changeToMode(long chipClusterPtr, ChangeToModeResponseCallback callback, Integer newMode, @Nullable Integer timedInvokeTimeoutMs);
-
-    public interface ChangeToModeResponseCallback {
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long newModeFieldID = 0L;
+      BaseTLVType newModetlvValue = new UIntType(newMode);
+      elements.add(new StructElement(newModeFieldID, newModetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long statusTextFieldID = 1L;
+          Optional<String> statusText = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == statusTextFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                statusText = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(status, statusText);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface ChangeToModeResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, Optional<String> statusText);
-      void onError(Exception error);
     }
 
-    public interface SupportedModesAttributeCallback {
+    public interface SupportedModesAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.RvcCleanModeClusterModeOptionStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface OnModeAttributeCallback {
+    public interface OnModeAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readSupportedModesAttribute(
         SupportedModesAttributeCallback callback) {
-        readSupportedModesAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_MODES_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.RvcCleanModeClusterModeOptionStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SUPPORTED_MODES_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSupportedModesAttribute(
         SupportedModesAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSupportedModesAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_MODES_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.RvcCleanModeClusterModeOptionStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SUPPORTED_MODES_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentModeAttribute(
         IntegerAttributeCallback callback) {
-        readCurrentModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_MODE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentModeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOnModeAttribute(
         OnModeAttributeCallback callback) {
-        readOnModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ON_MODE_ATTRIBUTE_ID, true);
     }
 
     public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOnModeAttribute(chipClusterPtr, callback, value, null);
+      writeOnModeAttribute(callback, value, 0);
     }
 
     public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOnModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ON_MODE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOnModeAttribute(
         OnModeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOnModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ON_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readSupportedModesAttribute(long chipClusterPtr, SupportedModesAttributeCallback callback);
-
-    private native void subscribeSupportedModesAttribute(long chipClusterPtr, SupportedModesAttributeCallback 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);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readOnModeAttribute(long chipClusterPtr, OnModeAttributeCallback callback);
-
-    private native void writeOnModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeOnModeAttribute(long chipClusterPtr, OnModeAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class TemperatureControlCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 86L;
 
+    private static final long TEMPERATURE_SETPOINT_ATTRIBUTE_ID = 0L;
+    private static final long MIN_TEMPERATURE_ATTRIBUTE_ID = 1L;
+    private static final long MAX_TEMPERATURE_ATTRIBUTE_ID = 2L;
+    private static final long STEP_ATTRIBUTE_ID = 3L;
+    private static final long SELECTED_TEMPERATURE_LEVEL_ATTRIBUTE_ID = 4L;
+    private static final long SUPPORTED_TEMPERATURE_LEVELS_ATTRIBUTE_ID = 5L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public TemperatureControlCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void setTemperature(DefaultClusterCallback callback, Optional<Integer> targetTemperature, Optional<Integer> targetTemperatureLevel) {
-      setTemperature(chipClusterPtr, callback, targetTemperature, targetTemperatureLevel, null);
+      setTemperature(callback, targetTemperature, targetTemperatureLevel, 0);
     }
 
     public void setTemperature(DefaultClusterCallback callback, Optional<Integer> targetTemperature, Optional<Integer> targetTemperatureLevel, int timedInvokeTimeoutMs) {
-      setTemperature(chipClusterPtr, callback, targetTemperature, targetTemperatureLevel, timedInvokeTimeoutMs);
-    }
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long targetTemperatureFieldID = 0L;
+      BaseTLVType targetTemperaturetlvValue = targetTemperature.<BaseTLVType>map((nonOptionaltargetTemperature) -> new IntType(nonOptionaltargetTemperature)).orElse(new EmptyType());
+      elements.add(new StructElement(targetTemperatureFieldID, targetTemperaturetlvValue));
+
+      final long targetTemperatureLevelFieldID = 1L;
+      BaseTLVType targetTemperatureLeveltlvValue = targetTemperatureLevel.<BaseTLVType>map((nonOptionaltargetTemperatureLevel) -> new UIntType(nonOptionaltargetTemperatureLevel)).orElse(new EmptyType());
+      elements.add(new StructElement(targetTemperatureLevelFieldID, targetTemperatureLeveltlvValue));
 
-    private native void setTemperature(long chipClusterPtr, DefaultClusterCallback callback, Optional<Integer> targetTemperature, Optional<Integer> targetTemperatureLevel, @Nullable Integer timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface SupportedTemperatureLevelsAttributeCallback {
+    public interface SupportedTemperatureLevelsAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<String> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readTemperatureSetpointAttribute(
         IntegerAttributeCallback callback) {
-        readTemperatureSetpointAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TEMPERATURE_SETPOINT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TEMPERATURE_SETPOINT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTemperatureSetpointAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTemperatureSetpointAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TEMPERATURE_SETPOINT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TEMPERATURE_SETPOINT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinTemperatureAttribute(
         IntegerAttributeCallback callback) {
-        readMinTemperatureAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_TEMPERATURE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_TEMPERATURE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinTemperatureAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinTemperatureAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_TEMPERATURE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_TEMPERATURE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxTemperatureAttribute(
         IntegerAttributeCallback callback) {
-        readMaxTemperatureAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_TEMPERATURE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_TEMPERATURE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxTemperatureAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxTemperatureAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_TEMPERATURE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_TEMPERATURE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readStepAttribute(
         IntegerAttributeCallback callback) {
-        readStepAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STEP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, STEP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeStepAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeStepAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STEP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, STEP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSelectedTemperatureLevelAttribute(
         IntegerAttributeCallback callback) {
-        readSelectedTemperatureLevelAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SELECTED_TEMPERATURE_LEVEL_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SELECTED_TEMPERATURE_LEVEL_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSelectedTemperatureLevelAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSelectedTemperatureLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SELECTED_TEMPERATURE_LEVEL_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SELECTED_TEMPERATURE_LEVEL_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSupportedTemperatureLevelsAttribute(
         SupportedTemperatureLevelsAttributeCallback callback) {
-        readSupportedTemperatureLevelsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_TEMPERATURE_LEVELS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<String> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SUPPORTED_TEMPERATURE_LEVELS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSupportedTemperatureLevelsAttribute(
         SupportedTemperatureLevelsAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSupportedTemperatureLevelsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_TEMPERATURE_LEVELS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<String> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SUPPORTED_TEMPERATURE_LEVELS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readTemperatureSetpointAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
+  }
 
-    private native void subscribeTemperatureSetpointAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+  public static class RefrigeratorAlarmCluster extends BaseChipCluster {
+    public static final long CLUSTER_ID = 87L;
 
-    private native void readMinTemperatureAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    private static final long MASK_ATTRIBUTE_ID = 0L;
+    private static final long STATE_ATTRIBUTE_ID = 2L;
+    private static final long SUPPORTED_ATTRIBUTE_ID = 3L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
 
-    private native void subscribeMinTemperatureAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public RefrigeratorAlarmCluster(long devicePtr, int endpointId) {
+      super(devicePtr, endpointId, CLUSTER_ID);
+    }
 
-    private native void readMaxTemperatureAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    @Override
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    private native void subscribeMaxTemperatureAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void readStepAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void subscribeStepAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void readSelectedTemperatureLevelAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void subscribeSelectedTemperatureLevelAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void readMaskAttribute(
+        LongAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MASK_ATTRIBUTE_ID);
 
-    private native void readSupportedTemperatureLevelsAttribute(long chipClusterPtr, SupportedTemperatureLevelsAttributeCallback callback);
-
-    private native void subscribeSupportedTemperatureLevelsAttribute(long chipClusterPtr, SupportedTemperatureLevelsAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-  }
-
-  public static class RefrigeratorAlarmCluster extends BaseChipCluster {
-    public static final long CLUSTER_ID = 87L;
-
-    public RefrigeratorAlarmCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
-    }
-
-    @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
-
-    public interface GeneratedCommandListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface AcceptedCommandListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface EventListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface AttributeListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public void readMaskAttribute(
-        LongAttributeCallback callback) {
-        readMaskAttribute(chipClusterPtr, callback);
-    }
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MASK_ATTRIBUTE_ID, true);
+    }
 
     public void subscribeMaskAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MASK_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MASK_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readStateAttribute(
         LongAttributeCallback callback) {
-        readStateAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STATE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, STATE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeStateAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeStateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STATE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, STATE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSupportedAttribute(
         LongAttributeCallback callback) {
-        readSupportedAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SUPPORTED_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSupportedAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SUPPORTED_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readMaskAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeMaskAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readStateAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeStateAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSupportedAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeSupportedAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class DishwasherModeCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 89L;
 
+    private static final long SUPPORTED_MODES_ATTRIBUTE_ID = 0L;
+    private static final long CURRENT_MODE_ATTRIBUTE_ID = 1L;
+    private static final long START_UP_MODE_ATTRIBUTE_ID = 2L;
+    private static final long ON_MODE_ATTRIBUTE_ID = 3L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public DishwasherModeCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void changeToMode(ChangeToModeResponseCallback callback, Integer newMode) {
-      changeToMode(chipClusterPtr, callback, newMode, null);
+      changeToMode(callback, newMode, 0);
     }
 
     public void changeToMode(ChangeToModeResponseCallback callback, Integer newMode, int timedInvokeTimeoutMs) {
-      changeToMode(chipClusterPtr, callback, newMode, timedInvokeTimeoutMs);
-    }
-
-    private native void changeToMode(long chipClusterPtr, ChangeToModeResponseCallback callback, Integer newMode, @Nullable Integer timedInvokeTimeoutMs);
-
-    public interface ChangeToModeResponseCallback {
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long newModeFieldID = 0L;
+      BaseTLVType newModetlvValue = new UIntType(newMode);
+      elements.add(new StructElement(newModeFieldID, newModetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long statusTextFieldID = 1L;
+          Optional<String> statusText = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == statusTextFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                statusText = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(status, statusText);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface ChangeToModeResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, Optional<String> statusText);
-      void onError(Exception error);
     }
 
-    public interface SupportedModesAttributeCallback {
+    public interface SupportedModesAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.DishwasherModeClusterModeOptionStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface StartUpModeAttributeCallback {
+    public interface StartUpModeAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface OnModeAttributeCallback {
+    public interface OnModeAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readSupportedModesAttribute(
         SupportedModesAttributeCallback callback) {
-        readSupportedModesAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_MODES_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.DishwasherModeClusterModeOptionStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SUPPORTED_MODES_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSupportedModesAttribute(
         SupportedModesAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSupportedModesAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_MODES_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.DishwasherModeClusterModeOptionStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SUPPORTED_MODES_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentModeAttribute(
         IntegerAttributeCallback callback) {
-        readCurrentModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_MODE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentModeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readStartUpModeAttribute(
         StartUpModeAttributeCallback callback) {
-        readStartUpModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, START_UP_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, START_UP_MODE_ATTRIBUTE_ID, true);
     }
 
     public void writeStartUpModeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeStartUpModeAttribute(chipClusterPtr, callback, value, null);
+      writeStartUpModeAttribute(callback, value, 0);
     }
 
     public void writeStartUpModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeStartUpModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), START_UP_MODE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeStartUpModeAttribute(
         StartUpModeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeStartUpModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, START_UP_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, START_UP_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOnModeAttribute(
         OnModeAttributeCallback callback) {
-        readOnModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ON_MODE_ATTRIBUTE_ID, true);
     }
 
     public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOnModeAttribute(chipClusterPtr, callback, value, null);
+      writeOnModeAttribute(callback, value, 0);
     }
 
     public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOnModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ON_MODE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOnModeAttribute(
         OnModeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOnModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ON_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ON_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readSupportedModesAttribute(long chipClusterPtr, SupportedModesAttributeCallback callback);
-
-    private native void subscribeSupportedModesAttribute(long chipClusterPtr, SupportedModesAttributeCallback 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 readStartUpModeAttribute(long chipClusterPtr, StartUpModeAttributeCallback callback);
-
-    private native void writeStartUpModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeStartUpModeAttribute(long chipClusterPtr, StartUpModeAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readOnModeAttribute(long chipClusterPtr, OnModeAttributeCallback callback);
-
-    private native void writeOnModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeOnModeAttribute(long chipClusterPtr, OnModeAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class AirQualityCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 91L;
 
+    private static final long AIR_QUALITY_ATTRIBUTE_ID = 0L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public AirQualityCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readAirQualityAttribute(
         IntegerAttributeCallback callback) {
-        readAirQualityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AIR_QUALITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AIR_QUALITY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAirQualityAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAirQualityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AIR_QUALITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AIR_QUALITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readAirQualityAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeAirQualityAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    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);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class SmokeCoAlarmCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 92L;
 
+    private static final long EXPRESSED_STATE_ATTRIBUTE_ID = 0L;
+    private static final long SMOKE_STATE_ATTRIBUTE_ID = 1L;
+    private static final long C_O_STATE_ATTRIBUTE_ID = 2L;
+    private static final long BATTERY_ALERT_ATTRIBUTE_ID = 3L;
+    private static final long DEVICE_MUTED_ATTRIBUTE_ID = 4L;
+    private static final long TEST_IN_PROGRESS_ATTRIBUTE_ID = 5L;
+    private static final long HARDWARE_FAULT_ALERT_ATTRIBUTE_ID = 6L;
+    private static final long END_OF_SERVICE_ALERT_ATTRIBUTE_ID = 7L;
+    private static final long INTERCONNECT_SMOKE_ALARM_ATTRIBUTE_ID = 8L;
+    private static final long INTERCONNECT_C_O_ALARM_ATTRIBUTE_ID = 9L;
+    private static final long CONTAMINATION_STATE_ATTRIBUTE_ID = 10L;
+    private static final long SMOKE_SENSITIVITY_LEVEL_ATTRIBUTE_ID = 11L;
+    private static final long EXPIRY_DATE_ATTRIBUTE_ID = 12L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public SmokeCoAlarmCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void selfTestRequest(DefaultClusterCallback callback) {
-      selfTestRequest(chipClusterPtr, callback, null);
+      selfTestRequest(callback, 0);
     }
 
     public void selfTestRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      selfTestRequest(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
+      final long commandId = 0L;
 
-    private native void selfTestRequest(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readExpressedStateAttribute(
         IntegerAttributeCallback callback) {
-        readExpressedStateAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EXPRESSED_STATE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EXPRESSED_STATE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeExpressedStateAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeExpressedStateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EXPRESSED_STATE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EXPRESSED_STATE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSmokeStateAttribute(
         IntegerAttributeCallback callback) {
-        readSmokeStateAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SMOKE_STATE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SMOKE_STATE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSmokeStateAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSmokeStateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SMOKE_STATE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SMOKE_STATE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCOStateAttribute(
         IntegerAttributeCallback callback) {
-        readCOStateAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, C_O_STATE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, C_O_STATE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCOStateAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCOStateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, C_O_STATE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, C_O_STATE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBatteryAlertAttribute(
         IntegerAttributeCallback callback) {
-        readBatteryAlertAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BATTERY_ALERT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BATTERY_ALERT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBatteryAlertAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBatteryAlertAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BATTERY_ALERT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BATTERY_ALERT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDeviceMutedAttribute(
         IntegerAttributeCallback callback) {
-        readDeviceMutedAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DEVICE_MUTED_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DEVICE_MUTED_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDeviceMutedAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDeviceMutedAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DEVICE_MUTED_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DEVICE_MUTED_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTestInProgressAttribute(
         BooleanAttributeCallback callback) {
-        readTestInProgressAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TEST_IN_PROGRESS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TEST_IN_PROGRESS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTestInProgressAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTestInProgressAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TEST_IN_PROGRESS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TEST_IN_PROGRESS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readHardwareFaultAlertAttribute(
         BooleanAttributeCallback callback) {
-        readHardwareFaultAlertAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, HARDWARE_FAULT_ALERT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, HARDWARE_FAULT_ALERT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeHardwareFaultAlertAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeHardwareFaultAlertAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, HARDWARE_FAULT_ALERT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, HARDWARE_FAULT_ALERT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEndOfServiceAlertAttribute(
         IntegerAttributeCallback callback) {
-        readEndOfServiceAlertAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, END_OF_SERVICE_ALERT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, END_OF_SERVICE_ALERT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEndOfServiceAlertAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEndOfServiceAlertAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, END_OF_SERVICE_ALERT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, END_OF_SERVICE_ALERT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readInterconnectSmokeAlarmAttribute(
         IntegerAttributeCallback callback) {
-        readInterconnectSmokeAlarmAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INTERCONNECT_SMOKE_ALARM_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INTERCONNECT_SMOKE_ALARM_ATTRIBUTE_ID, true);
     }
 
     public void subscribeInterconnectSmokeAlarmAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInterconnectSmokeAlarmAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INTERCONNECT_SMOKE_ALARM_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INTERCONNECT_SMOKE_ALARM_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readInterconnectCOAlarmAttribute(
         IntegerAttributeCallback callback) {
-        readInterconnectCOAlarmAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INTERCONNECT_C_O_ALARM_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INTERCONNECT_C_O_ALARM_ATTRIBUTE_ID, true);
     }
 
     public void subscribeInterconnectCOAlarmAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInterconnectCOAlarmAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INTERCONNECT_C_O_ALARM_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INTERCONNECT_C_O_ALARM_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readContaminationStateAttribute(
         IntegerAttributeCallback callback) {
-        readContaminationStateAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CONTAMINATION_STATE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CONTAMINATION_STATE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeContaminationStateAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeContaminationStateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CONTAMINATION_STATE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CONTAMINATION_STATE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSmokeSensitivityLevelAttribute(
         IntegerAttributeCallback callback) {
-        readSmokeSensitivityLevelAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SMOKE_SENSITIVITY_LEVEL_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SMOKE_SENSITIVITY_LEVEL_ATTRIBUTE_ID, true);
     }
 
     public void writeSmokeSensitivityLevelAttribute(DefaultClusterCallback callback, Integer value) {
-        writeSmokeSensitivityLevelAttribute(chipClusterPtr, callback, value, null);
+      writeSmokeSensitivityLevelAttribute(callback, value, 0);
     }
 
     public void writeSmokeSensitivityLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeSmokeSensitivityLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), SMOKE_SENSITIVITY_LEVEL_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeSmokeSensitivityLevelAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSmokeSensitivityLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SMOKE_SENSITIVITY_LEVEL_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SMOKE_SENSITIVITY_LEVEL_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readExpiryDateAttribute(
         LongAttributeCallback callback) {
-        readExpiryDateAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EXPIRY_DATE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EXPIRY_DATE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeExpiryDateAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeExpiryDateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EXPIRY_DATE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EXPIRY_DATE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readExpressedStateAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeExpressedStateAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSmokeStateAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeSmokeStateAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readCOStateAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeCOStateAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBatteryAlertAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeBatteryAlertAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readDeviceMutedAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeDeviceMutedAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readTestInProgressAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
-
-    private native void subscribeTestInProgressAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readHardwareFaultAlertAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
-
-    private native void subscribeHardwareFaultAlertAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEndOfServiceAlertAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeEndOfServiceAlertAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readInterconnectSmokeAlarmAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeInterconnectSmokeAlarmAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readInterconnectCOAlarmAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeInterconnectCOAlarmAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readContaminationStateAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeContaminationStateAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSmokeSensitivityLevelAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeSmokeSensitivityLevelAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeSmokeSensitivityLevelAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readExpiryDateAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeExpiryDateAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class DishwasherAlarmCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 93L;
 
+    private static final long MASK_ATTRIBUTE_ID = 0L;
+    private static final long LATCH_ATTRIBUTE_ID = 1L;
+    private static final long STATE_ATTRIBUTE_ID = 2L;
+    private static final long SUPPORTED_ATTRIBUTE_ID = 3L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public DishwasherAlarmCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void reset(DefaultClusterCallback callback, Long alarms) {
-      reset(chipClusterPtr, callback, alarms, null);
+      reset(callback, alarms, 0);
     }
 
     public void reset(DefaultClusterCallback callback, Long alarms, int timedInvokeTimeoutMs) {
-      reset(chipClusterPtr, callback, alarms, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long alarmsFieldID = 0L;
+      BaseTLVType alarmstlvValue = new UIntType(alarms);
+      elements.add(new StructElement(alarmsFieldID, alarmstlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void modifyEnabledAlarms(DefaultClusterCallback callback, Long mask) {
-      modifyEnabledAlarms(chipClusterPtr, callback, mask, null);
+      modifyEnabledAlarms(callback, mask, 0);
     }
 
     public void modifyEnabledAlarms(DefaultClusterCallback callback, Long mask, int timedInvokeTimeoutMs) {
-      modifyEnabledAlarms(chipClusterPtr, callback, mask, timedInvokeTimeoutMs);
-    }
+      final long commandId = 1L;
 
-    private native void reset(long chipClusterPtr, DefaultClusterCallback callback, Long alarms, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long maskFieldID = 0L;
+      BaseTLVType masktlvValue = new UIntType(mask);
+      elements.add(new StructElement(maskFieldID, masktlvValue));
 
-    private native void modifyEnabledAlarms(long chipClusterPtr, DefaultClusterCallback callback, Long mask, @Nullable Integer timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readMaskAttribute(
         LongAttributeCallback callback) {
-        readMaskAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MASK_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MASK_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaskAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MASK_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MASK_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLatchAttribute(
         LongAttributeCallback callback) {
-        readLatchAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LATCH_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LATCH_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLatchAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLatchAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LATCH_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LATCH_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readStateAttribute(
         LongAttributeCallback callback) {
-        readStateAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STATE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, STATE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeStateAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeStateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STATE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, STATE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSupportedAttribute(
         LongAttributeCallback callback) {
-        readSupportedAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SUPPORTED_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSupportedAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SUPPORTED_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readMaskAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeMaskAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLatchAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeLatchAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readStateAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeStateAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSupportedAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeSupportedAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    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);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class MicrowaveOvenModeCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 94L;
 
+    private static final long SUPPORTED_MODES_ATTRIBUTE_ID = 0L;
+    private static final long CURRENT_MODE_ATTRIBUTE_ID = 1L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public MicrowaveOvenModeCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface SupportedModesAttributeCallback {
+    public interface SupportedModesAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.MicrowaveOvenModeClusterModeOptionStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readSupportedModesAttribute(
         SupportedModesAttributeCallback callback) {
-        readSupportedModesAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_MODES_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.MicrowaveOvenModeClusterModeOptionStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SUPPORTED_MODES_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSupportedModesAttribute(
         SupportedModesAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSupportedModesAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_MODES_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.MicrowaveOvenModeClusterModeOptionStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SUPPORTED_MODES_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentModeAttribute(
         IntegerAttributeCallback callback) {
-        readCurrentModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_MODE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentModeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readSupportedModesAttribute(long chipClusterPtr, SupportedModesAttributeCallback callback);
-
-    private native void subscribeSupportedModesAttribute(long chipClusterPtr, SupportedModesAttributeCallback 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 readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class MicrowaveOvenControlCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 95L;
 
+    private static final long COOK_TIME_ATTRIBUTE_ID = 1L;
+    private static final long POWER_SETTING_ATTRIBUTE_ID = 2L;
+    private static final long MIN_POWER_ATTRIBUTE_ID = 3L;
+    private static final long MAX_POWER_ATTRIBUTE_ID = 4L;
+    private static final long POWER_STEP_ATTRIBUTE_ID = 5L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public MicrowaveOvenControlCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void setCookingParameters(DefaultClusterCallback callback, Optional<Integer> cookMode, Optional<Long> cookTime, Optional<Integer> powerSetting) {
-      setCookingParameters(chipClusterPtr, callback, cookMode, cookTime, powerSetting, null);
+      setCookingParameters(callback, cookMode, cookTime, powerSetting, 0);
     }
 
     public void setCookingParameters(DefaultClusterCallback callback, Optional<Integer> cookMode, Optional<Long> cookTime, Optional<Integer> powerSetting, int timedInvokeTimeoutMs) {
-      setCookingParameters(chipClusterPtr, callback, cookMode, cookTime, powerSetting, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long cookModeFieldID = 0L;
+      BaseTLVType cookModetlvValue = cookMode.<BaseTLVType>map((nonOptionalcookMode) -> new UIntType(nonOptionalcookMode)).orElse(new EmptyType());
+      elements.add(new StructElement(cookModeFieldID, cookModetlvValue));
+
+      final long cookTimeFieldID = 1L;
+      BaseTLVType cookTimetlvValue = cookTime.<BaseTLVType>map((nonOptionalcookTime) -> new UIntType(nonOptionalcookTime)).orElse(new EmptyType());
+      elements.add(new StructElement(cookTimeFieldID, cookTimetlvValue));
+
+      final long powerSettingFieldID = 2L;
+      BaseTLVType powerSettingtlvValue = powerSetting.<BaseTLVType>map((nonOptionalpowerSetting) -> new UIntType(nonOptionalpowerSetting)).orElse(new EmptyType());
+      elements.add(new StructElement(powerSettingFieldID, powerSettingtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void addMoreTime(DefaultClusterCallback callback, Long timeToAdd) {
-      addMoreTime(chipClusterPtr, callback, timeToAdd, null);
+      addMoreTime(callback, timeToAdd, 0);
     }
 
     public void addMoreTime(DefaultClusterCallback callback, Long timeToAdd, int timedInvokeTimeoutMs) {
-      addMoreTime(chipClusterPtr, callback, timeToAdd, timedInvokeTimeoutMs);
-    }
+      final long commandId = 1L;
 
-    private native void setCookingParameters(long chipClusterPtr, DefaultClusterCallback callback, Optional<Integer> cookMode, Optional<Long> cookTime, Optional<Integer> powerSetting, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long timeToAddFieldID = 0L;
+      BaseTLVType timeToAddtlvValue = new UIntType(timeToAdd);
+      elements.add(new StructElement(timeToAddFieldID, timeToAddtlvValue));
 
-    private native void addMoreTime(long chipClusterPtr, DefaultClusterCallback callback, Long timeToAdd, @Nullable Integer timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readCookTimeAttribute(
         LongAttributeCallback callback) {
-        readCookTimeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COOK_TIME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COOK_TIME_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCookTimeAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCookTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COOK_TIME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COOK_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPowerSettingAttribute(
         IntegerAttributeCallback callback) {
-        readPowerSettingAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, POWER_SETTING_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, POWER_SETTING_ATTRIBUTE_ID, true);
     }
 
     public void subscribePowerSettingAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePowerSettingAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, POWER_SETTING_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, POWER_SETTING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinPowerAttribute(
         IntegerAttributeCallback callback) {
-        readMinPowerAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_POWER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_POWER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinPowerAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinPowerAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_POWER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_POWER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxPowerAttribute(
         IntegerAttributeCallback callback) {
-        readMaxPowerAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_POWER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_POWER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxPowerAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxPowerAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_POWER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_POWER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPowerStepAttribute(
         IntegerAttributeCallback callback) {
-        readPowerStepAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, POWER_STEP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, POWER_STEP_ATTRIBUTE_ID, true);
     }
 
     public void subscribePowerStepAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePowerStepAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, POWER_STEP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, POWER_STEP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readCookTimeAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeCookTimeAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPowerSettingAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribePowerSettingAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMinPowerAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMinPowerAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMaxPowerAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMaxPowerAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPowerStepAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribePowerStepAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class OperationalStateCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 96L;
 
+    private static final long PHASE_LIST_ATTRIBUTE_ID = 0L;
+    private static final long CURRENT_PHASE_ATTRIBUTE_ID = 1L;
+    private static final long COUNTDOWN_TIME_ATTRIBUTE_ID = 2L;
+    private static final long OPERATIONAL_STATE_LIST_ATTRIBUTE_ID = 3L;
+    private static final long OPERATIONAL_STATE_ATTRIBUTE_ID = 4L;
+    private static final long OPERATIONAL_ERROR_ATTRIBUTE_ID = 5L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public OperationalStateCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void pause(OperationalCommandResponseCallback callback) {
-      pause(chipClusterPtr, callback, null);
+      pause(callback, 0);
     }
 
     public void pause(OperationalCommandResponseCallback callback, int timedInvokeTimeoutMs) {
-      pause(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long commandResponseStateFieldID = 0L;
+          ChipStructs.OperationalStateClusterErrorStateStruct commandResponseState = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == commandResponseStateFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+                StructType castingValue = element.value(StructType.class);
+                commandResponseState = ChipStructs.OperationalStateClusterErrorStateStruct.decodeTlv(castingValue);
+              }
+            }
+          }
+          callback.onSuccess(commandResponseState);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void stop(OperationalCommandResponseCallback callback) {
-      stop(chipClusterPtr, callback, null);
+      stop(callback, 0);
     }
 
     public void stop(OperationalCommandResponseCallback callback, int timedInvokeTimeoutMs) {
-      stop(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 1L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long commandResponseStateFieldID = 0L;
+          ChipStructs.OperationalStateClusterErrorStateStruct commandResponseState = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == commandResponseStateFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+                StructType castingValue = element.value(StructType.class);
+                commandResponseState = ChipStructs.OperationalStateClusterErrorStateStruct.decodeTlv(castingValue);
+              }
+            }
+          }
+          callback.onSuccess(commandResponseState);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void start(OperationalCommandResponseCallback callback) {
-      start(chipClusterPtr, callback, null);
+      start(callback, 0);
     }
 
     public void start(OperationalCommandResponseCallback callback, int timedInvokeTimeoutMs) {
-      start(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 2L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long commandResponseStateFieldID = 0L;
+          ChipStructs.OperationalStateClusterErrorStateStruct commandResponseState = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == commandResponseStateFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+                StructType castingValue = element.value(StructType.class);
+                commandResponseState = ChipStructs.OperationalStateClusterErrorStateStruct.decodeTlv(castingValue);
+              }
+            }
+          }
+          callback.onSuccess(commandResponseState);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void resume(OperationalCommandResponseCallback callback) {
-      resume(chipClusterPtr, callback, null);
+      resume(callback, 0);
     }
 
     public void resume(OperationalCommandResponseCallback callback, int timedInvokeTimeoutMs) {
-      resume(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
-
-    private native void pause(long chipClusterPtr, OperationalCommandResponseCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void stop(long chipClusterPtr, OperationalCommandResponseCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void start(long chipClusterPtr, OperationalCommandResponseCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void resume(long chipClusterPtr, OperationalCommandResponseCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    public interface OperationalCommandResponseCallback {
+      final long commandId = 3L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long commandResponseStateFieldID = 0L;
+          ChipStructs.OperationalStateClusterErrorStateStruct commandResponseState = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == commandResponseStateFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+                StructType castingValue = element.value(StructType.class);
+                commandResponseState = ChipStructs.OperationalStateClusterErrorStateStruct.decodeTlv(castingValue);
+              }
+            }
+          }
+          callback.onSuccess(commandResponseState);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface OperationalCommandResponseCallback extends BaseClusterCallback {
       void onSuccess(ChipStructs.OperationalStateClusterErrorStateStruct commandResponseState);
-      void onError(Exception error);
     }
 
-    public interface PhaseListAttributeCallback {
+    public interface PhaseListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable List<String> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface CurrentPhaseAttributeCallback {
+    public interface CurrentPhaseAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface CountdownTimeAttributeCallback {
+    public interface CountdownTimeAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface OperationalStateListAttributeCallback {
+    public interface OperationalStateListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.OperationalStateClusterOperationalStateStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface OperationalErrorAttributeCallback {
+    public interface OperationalErrorAttributeCallback extends BaseAttributeCallback {
       void onSuccess(ChipStructs.OperationalStateClusterErrorStateStruct value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readPhaseListAttribute(
         PhaseListAttributeCallback callback) {
-        readPhaseListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PHASE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable List<String> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PHASE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribePhaseListAttribute(
         PhaseListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePhaseListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PHASE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable List<String> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PHASE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentPhaseAttribute(
         CurrentPhaseAttributeCallback callback) {
-        readCurrentPhaseAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_PHASE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_PHASE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentPhaseAttribute(
         CurrentPhaseAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentPhaseAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_PHASE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_PHASE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCountdownTimeAttribute(
         CountdownTimeAttributeCallback callback) {
-        readCountdownTimeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COUNTDOWN_TIME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COUNTDOWN_TIME_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCountdownTimeAttribute(
         CountdownTimeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCountdownTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COUNTDOWN_TIME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COUNTDOWN_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOperationalStateListAttribute(
         OperationalStateListAttributeCallback callback) {
-        readOperationalStateListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPERATIONAL_STATE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.OperationalStateClusterOperationalStateStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OPERATIONAL_STATE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeOperationalStateListAttribute(
         OperationalStateListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOperationalStateListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPERATIONAL_STATE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.OperationalStateClusterOperationalStateStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OPERATIONAL_STATE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOperationalStateAttribute(
         IntegerAttributeCallback callback) {
-        readOperationalStateAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPERATIONAL_STATE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OPERATIONAL_STATE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeOperationalStateAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOperationalStateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPERATIONAL_STATE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OPERATIONAL_STATE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOperationalErrorAttribute(
         OperationalErrorAttributeCallback callback) {
-        readOperationalErrorAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPERATIONAL_ERROR_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            ChipStructs.OperationalStateClusterErrorStateStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OPERATIONAL_ERROR_ATTRIBUTE_ID, true);
     }
 
     public void subscribeOperationalErrorAttribute(
         OperationalErrorAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOperationalErrorAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPERATIONAL_ERROR_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            ChipStructs.OperationalStateClusterErrorStateStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OPERATIONAL_ERROR_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readPhaseListAttribute(long chipClusterPtr, PhaseListAttributeCallback callback);
-
-    private native void subscribePhaseListAttribute(long chipClusterPtr, PhaseListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readCurrentPhaseAttribute(long chipClusterPtr, CurrentPhaseAttributeCallback callback);
-
-    private native void subscribeCurrentPhaseAttribute(long chipClusterPtr, CurrentPhaseAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readCountdownTimeAttribute(long chipClusterPtr, CountdownTimeAttributeCallback callback);
-
-    private native void subscribeCountdownTimeAttribute(long chipClusterPtr, CountdownTimeAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readOperationalStateListAttribute(long chipClusterPtr, OperationalStateListAttributeCallback callback);
-
-    private native void subscribeOperationalStateListAttribute(long chipClusterPtr, OperationalStateListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readOperationalStateAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeOperationalStateAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readOperationalErrorAttribute(long chipClusterPtr, OperationalErrorAttributeCallback callback);
-
-    private native void subscribeOperationalErrorAttribute(long chipClusterPtr, OperationalErrorAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    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);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class RvcOperationalStateCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 97L;
 
+    private static final long PHASE_LIST_ATTRIBUTE_ID = 0L;
+    private static final long CURRENT_PHASE_ATTRIBUTE_ID = 1L;
+    private static final long COUNTDOWN_TIME_ATTRIBUTE_ID = 2L;
+    private static final long OPERATIONAL_STATE_LIST_ATTRIBUTE_ID = 3L;
+    private static final long OPERATIONAL_STATE_ATTRIBUTE_ID = 4L;
+    private static final long OPERATIONAL_ERROR_ATTRIBUTE_ID = 5L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public RvcOperationalStateCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void pause(OperationalCommandResponseCallback callback) {
-      pause(chipClusterPtr, callback, null);
+      pause(callback, 0);
     }
 
     public void pause(OperationalCommandResponseCallback callback, int timedInvokeTimeoutMs) {
-      pause(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long commandResponseStateFieldID = 0L;
+          ChipStructs.RvcOperationalStateClusterErrorStateStruct commandResponseState = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == commandResponseStateFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+                StructType castingValue = element.value(StructType.class);
+                commandResponseState = ChipStructs.RvcOperationalStateClusterErrorStateStruct.decodeTlv(castingValue);
+              }
+            }
+          }
+          callback.onSuccess(commandResponseState);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void stop(OperationalCommandResponseCallback callback) {
-      stop(chipClusterPtr, callback, null);
+      stop(callback, 0);
     }
 
     public void stop(OperationalCommandResponseCallback callback, int timedInvokeTimeoutMs) {
-      stop(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 1L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long commandResponseStateFieldID = 0L;
+          ChipStructs.RvcOperationalStateClusterErrorStateStruct commandResponseState = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == commandResponseStateFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+                StructType castingValue = element.value(StructType.class);
+                commandResponseState = ChipStructs.RvcOperationalStateClusterErrorStateStruct.decodeTlv(castingValue);
+              }
+            }
+          }
+          callback.onSuccess(commandResponseState);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void start(OperationalCommandResponseCallback callback) {
-      start(chipClusterPtr, callback, null);
+      start(callback, 0);
     }
 
     public void start(OperationalCommandResponseCallback callback, int timedInvokeTimeoutMs) {
-      start(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 2L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long commandResponseStateFieldID = 0L;
+          ChipStructs.RvcOperationalStateClusterErrorStateStruct commandResponseState = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == commandResponseStateFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+                StructType castingValue = element.value(StructType.class);
+                commandResponseState = ChipStructs.RvcOperationalStateClusterErrorStateStruct.decodeTlv(castingValue);
+              }
+            }
+          }
+          callback.onSuccess(commandResponseState);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void resume(OperationalCommandResponseCallback callback) {
-      resume(chipClusterPtr, callback, null);
+      resume(callback, 0);
     }
 
     public void resume(OperationalCommandResponseCallback callback, int timedInvokeTimeoutMs) {
-      resume(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
-
-    private native void pause(long chipClusterPtr, OperationalCommandResponseCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void stop(long chipClusterPtr, OperationalCommandResponseCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void start(long chipClusterPtr, OperationalCommandResponseCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void resume(long chipClusterPtr, OperationalCommandResponseCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    public interface OperationalCommandResponseCallback {
+      final long commandId = 3L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long commandResponseStateFieldID = 0L;
+          ChipStructs.RvcOperationalStateClusterErrorStateStruct commandResponseState = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == commandResponseStateFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+                StructType castingValue = element.value(StructType.class);
+                commandResponseState = ChipStructs.RvcOperationalStateClusterErrorStateStruct.decodeTlv(castingValue);
+              }
+            }
+          }
+          callback.onSuccess(commandResponseState);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface OperationalCommandResponseCallback extends BaseClusterCallback {
       void onSuccess(ChipStructs.RvcOperationalStateClusterErrorStateStruct commandResponseState);
-      void onError(Exception error);
     }
 
-    public interface PhaseListAttributeCallback {
+    public interface PhaseListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable List<String> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface CurrentPhaseAttributeCallback {
+    public interface CurrentPhaseAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface CountdownTimeAttributeCallback {
+    public interface CountdownTimeAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface OperationalStateListAttributeCallback {
+    public interface OperationalStateListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.RvcOperationalStateClusterOperationalStateStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface OperationalErrorAttributeCallback {
+    public interface OperationalErrorAttributeCallback extends BaseAttributeCallback {
       void onSuccess(ChipStructs.RvcOperationalStateClusterErrorStateStruct value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readPhaseListAttribute(
         PhaseListAttributeCallback callback) {
-        readPhaseListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PHASE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable List<String> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PHASE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribePhaseListAttribute(
         PhaseListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePhaseListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PHASE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable List<String> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PHASE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentPhaseAttribute(
         CurrentPhaseAttributeCallback callback) {
-        readCurrentPhaseAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_PHASE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_PHASE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentPhaseAttribute(
         CurrentPhaseAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentPhaseAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_PHASE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_PHASE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCountdownTimeAttribute(
         CountdownTimeAttributeCallback callback) {
-        readCountdownTimeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COUNTDOWN_TIME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COUNTDOWN_TIME_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCountdownTimeAttribute(
         CountdownTimeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCountdownTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COUNTDOWN_TIME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COUNTDOWN_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOperationalStateListAttribute(
         OperationalStateListAttributeCallback callback) {
-        readOperationalStateListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPERATIONAL_STATE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.RvcOperationalStateClusterOperationalStateStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OPERATIONAL_STATE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeOperationalStateListAttribute(
         OperationalStateListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOperationalStateListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPERATIONAL_STATE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.RvcOperationalStateClusterOperationalStateStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OPERATIONAL_STATE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOperationalStateAttribute(
         IntegerAttributeCallback callback) {
-        readOperationalStateAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPERATIONAL_STATE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OPERATIONAL_STATE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeOperationalStateAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOperationalStateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPERATIONAL_STATE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OPERATIONAL_STATE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOperationalErrorAttribute(
         OperationalErrorAttributeCallback callback) {
-        readOperationalErrorAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPERATIONAL_ERROR_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            ChipStructs.RvcOperationalStateClusterErrorStateStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OPERATIONAL_ERROR_ATTRIBUTE_ID, true);
     }
 
     public void subscribeOperationalErrorAttribute(
         OperationalErrorAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOperationalErrorAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPERATIONAL_ERROR_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            ChipStructs.RvcOperationalStateClusterErrorStateStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OPERATIONAL_ERROR_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readPhaseListAttribute(long chipClusterPtr, PhaseListAttributeCallback callback);
-
-    private native void subscribePhaseListAttribute(long chipClusterPtr, PhaseListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readCurrentPhaseAttribute(long chipClusterPtr, CurrentPhaseAttributeCallback callback);
-
-    private native void subscribeCurrentPhaseAttribute(long chipClusterPtr, CurrentPhaseAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readCountdownTimeAttribute(long chipClusterPtr, CountdownTimeAttributeCallback callback);
-
-    private native void subscribeCountdownTimeAttribute(long chipClusterPtr, CountdownTimeAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readOperationalStateListAttribute(long chipClusterPtr, OperationalStateListAttributeCallback callback);
-
-    private native void subscribeOperationalStateListAttribute(long chipClusterPtr, OperationalStateListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readOperationalStateAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeOperationalStateAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readOperationalErrorAttribute(long chipClusterPtr, OperationalErrorAttributeCallback callback);
-
-    private native void subscribeOperationalErrorAttribute(long chipClusterPtr, OperationalErrorAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class HepaFilterMonitoringCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 113L;
 
+    private static final long CONDITION_ATTRIBUTE_ID = 0L;
+    private static final long DEGRADATION_DIRECTION_ATTRIBUTE_ID = 1L;
+    private static final long CHANGE_INDICATION_ATTRIBUTE_ID = 2L;
+    private static final long IN_PLACE_INDICATOR_ATTRIBUTE_ID = 3L;
+    private static final long LAST_CHANGED_TIME_ATTRIBUTE_ID = 4L;
+    private static final long REPLACEMENT_PRODUCT_LIST_ATTRIBUTE_ID = 5L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public HepaFilterMonitoringCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void resetCondition(DefaultClusterCallback callback) {
-      resetCondition(chipClusterPtr, callback, null);
+      resetCondition(callback, 0);
     }
 
     public void resetCondition(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      resetCondition(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
+      final long commandId = 0L;
 
-    private native void resetCondition(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface LastChangedTimeAttributeCallback {
+    public interface LastChangedTimeAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ReplacementProductListAttributeCallback {
+    public interface ReplacementProductListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.HepaFilterMonitoringClusterReplacementProductStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readConditionAttribute(
         IntegerAttributeCallback callback) {
-        readConditionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CONDITION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CONDITION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeConditionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeConditionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CONDITION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CONDITION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDegradationDirectionAttribute(
         IntegerAttributeCallback callback) {
-        readDegradationDirectionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DEGRADATION_DIRECTION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DEGRADATION_DIRECTION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDegradationDirectionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDegradationDirectionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DEGRADATION_DIRECTION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DEGRADATION_DIRECTION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readChangeIndicationAttribute(
         IntegerAttributeCallback callback) {
-        readChangeIndicationAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CHANGE_INDICATION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CHANGE_INDICATION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeChangeIndicationAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeChangeIndicationAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CHANGE_INDICATION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CHANGE_INDICATION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readInPlaceIndicatorAttribute(
         BooleanAttributeCallback callback) {
-        readInPlaceIndicatorAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, IN_PLACE_INDICATOR_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, IN_PLACE_INDICATOR_ATTRIBUTE_ID, true);
     }
 
     public void subscribeInPlaceIndicatorAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInPlaceIndicatorAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, IN_PLACE_INDICATOR_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, IN_PLACE_INDICATOR_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLastChangedTimeAttribute(
         LastChangedTimeAttributeCallback callback) {
-        readLastChangedTimeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAST_CHANGED_TIME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LAST_CHANGED_TIME_ATTRIBUTE_ID, true);
     }
 
     public void writeLastChangedTimeAttribute(DefaultClusterCallback callback, Long value) {
-        writeLastChangedTimeAttribute(chipClusterPtr, callback, value, null);
+      writeLastChangedTimeAttribute(callback, value, 0);
     }
 
     public void writeLastChangedTimeAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeLastChangedTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LAST_CHANGED_TIME_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeLastChangedTimeAttribute(
         LastChangedTimeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLastChangedTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAST_CHANGED_TIME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LAST_CHANGED_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readReplacementProductListAttribute(
         ReplacementProductListAttributeCallback callback) {
-        readReplacementProductListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REPLACEMENT_PRODUCT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.HepaFilterMonitoringClusterReplacementProductStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, REPLACEMENT_PRODUCT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeReplacementProductListAttribute(
         ReplacementProductListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeReplacementProductListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REPLACEMENT_PRODUCT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.HepaFilterMonitoringClusterReplacementProductStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, REPLACEMENT_PRODUCT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
+  }
 
-    private native void readConditionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+  public static class ActivatedCarbonFilterMonitoringCluster extends BaseChipCluster {
+    public static final long CLUSTER_ID = 114L;
 
-    private native void subscribeConditionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    private static final long CONDITION_ATTRIBUTE_ID = 0L;
+    private static final long DEGRADATION_DIRECTION_ATTRIBUTE_ID = 1L;
+    private static final long CHANGE_INDICATION_ATTRIBUTE_ID = 2L;
+    private static final long IN_PLACE_INDICATOR_ATTRIBUTE_ID = 3L;
+    private static final long LAST_CHANGED_TIME_ATTRIBUTE_ID = 4L;
+    private static final long REPLACEMENT_PRODUCT_LIST_ATTRIBUTE_ID = 5L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
 
-    private native void readDegradationDirectionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public ActivatedCarbonFilterMonitoringCluster(long devicePtr, int endpointId) {
+      super(devicePtr, endpointId, CLUSTER_ID);
+    }
 
-    private native void subscribeDegradationDirectionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    @Override
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    private native void readChangeIndicationAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeChangeIndicationAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readInPlaceIndicatorAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
-
-    private native void subscribeInPlaceIndicatorAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLastChangedTimeAttribute(long chipClusterPtr, LastChangedTimeAttributeCallback callback);
-
-    private native void writeLastChangedTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeLastChangedTimeAttribute(long chipClusterPtr, LastChangedTimeAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readReplacementProductListAttribute(long chipClusterPtr, ReplacementProductListAttributeCallback callback);
-
-    private native void subscribeReplacementProductListAttribute(long chipClusterPtr, ReplacementProductListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-  }
-
-  public static class ActivatedCarbonFilterMonitoringCluster extends BaseChipCluster {
-    public static final long CLUSTER_ID = 114L;
-
-    public ActivatedCarbonFilterMonitoringCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
-    }
-
-    @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
-
-    public void resetCondition(DefaultClusterCallback callback) {
-      resetCondition(chipClusterPtr, callback, null);
-    }
+    public void resetCondition(DefaultClusterCallback callback) {
+      resetCondition(callback, 0);
+    }
 
     public void resetCondition(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      resetCondition(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
+      final long commandId = 0L;
 
-    private native void resetCondition(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface LastChangedTimeAttributeCallback {
+    public interface LastChangedTimeAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ReplacementProductListAttributeCallback {
+    public interface ReplacementProductListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.ActivatedCarbonFilterMonitoringClusterReplacementProductStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readConditionAttribute(
         IntegerAttributeCallback callback) {
-        readConditionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CONDITION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CONDITION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeConditionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeConditionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CONDITION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CONDITION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDegradationDirectionAttribute(
         IntegerAttributeCallback callback) {
-        readDegradationDirectionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DEGRADATION_DIRECTION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DEGRADATION_DIRECTION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDegradationDirectionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDegradationDirectionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DEGRADATION_DIRECTION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DEGRADATION_DIRECTION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readChangeIndicationAttribute(
         IntegerAttributeCallback callback) {
-        readChangeIndicationAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CHANGE_INDICATION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CHANGE_INDICATION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeChangeIndicationAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeChangeIndicationAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CHANGE_INDICATION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CHANGE_INDICATION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readInPlaceIndicatorAttribute(
         BooleanAttributeCallback callback) {
-        readInPlaceIndicatorAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, IN_PLACE_INDICATOR_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, IN_PLACE_INDICATOR_ATTRIBUTE_ID, true);
     }
 
     public void subscribeInPlaceIndicatorAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInPlaceIndicatorAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, IN_PLACE_INDICATOR_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, IN_PLACE_INDICATOR_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLastChangedTimeAttribute(
         LastChangedTimeAttributeCallback callback) {
-        readLastChangedTimeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAST_CHANGED_TIME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LAST_CHANGED_TIME_ATTRIBUTE_ID, true);
     }
 
     public void writeLastChangedTimeAttribute(DefaultClusterCallback callback, Long value) {
-        writeLastChangedTimeAttribute(chipClusterPtr, callback, value, null);
+      writeLastChangedTimeAttribute(callback, value, 0);
     }
 
     public void writeLastChangedTimeAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeLastChangedTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LAST_CHANGED_TIME_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeLastChangedTimeAttribute(
         LastChangedTimeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLastChangedTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAST_CHANGED_TIME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LAST_CHANGED_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readReplacementProductListAttribute(
         ReplacementProductListAttributeCallback callback) {
-        readReplacementProductListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REPLACEMENT_PRODUCT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.ActivatedCarbonFilterMonitoringClusterReplacementProductStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, REPLACEMENT_PRODUCT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeReplacementProductListAttribute(
         ReplacementProductListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeReplacementProductListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REPLACEMENT_PRODUCT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.ActivatedCarbonFilterMonitoringClusterReplacementProductStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, REPLACEMENT_PRODUCT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readConditionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeConditionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readDegradationDirectionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeDegradationDirectionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readChangeIndicationAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeChangeIndicationAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readInPlaceIndicatorAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
-
-    private native void subscribeInPlaceIndicatorAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLastChangedTimeAttribute(long chipClusterPtr, LastChangedTimeAttributeCallback callback);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
+  }
 
-    private native void writeLastChangedTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+  public static class DoorLockCluster extends BaseChipCluster {
+    public static final long CLUSTER_ID = 257L;
 
-    private native void subscribeLastChangedTimeAttribute(long chipClusterPtr, LastChangedTimeAttributeCallback callback, int minInterval, int maxInterval);
+    private static final long LOCK_STATE_ATTRIBUTE_ID = 0L;
+    private static final long LOCK_TYPE_ATTRIBUTE_ID = 1L;
+    private static final long ACTUATOR_ENABLED_ATTRIBUTE_ID = 2L;
+    private static final long DOOR_STATE_ATTRIBUTE_ID = 3L;
+    private static final long DOOR_OPEN_EVENTS_ATTRIBUTE_ID = 4L;
+    private static final long DOOR_CLOSED_EVENTS_ATTRIBUTE_ID = 5L;
+    private static final long OPEN_PERIOD_ATTRIBUTE_ID = 6L;
+    private static final long NUMBER_OF_TOTAL_USERS_SUPPORTED_ATTRIBUTE_ID = 17L;
+    private static final long NUMBER_OF_P_I_N_USERS_SUPPORTED_ATTRIBUTE_ID = 18L;
+    private static final long NUMBER_OF_R_F_I_D_USERS_SUPPORTED_ATTRIBUTE_ID = 19L;
+    private static final long NUMBER_OF_WEEK_DAY_SCHEDULES_SUPPORTED_PER_USER_ATTRIBUTE_ID = 20L;
+    private static final long NUMBER_OF_YEAR_DAY_SCHEDULES_SUPPORTED_PER_USER_ATTRIBUTE_ID = 21L;
+    private static final long NUMBER_OF_HOLIDAY_SCHEDULES_SUPPORTED_ATTRIBUTE_ID = 22L;
+    private static final long MAX_P_I_N_CODE_LENGTH_ATTRIBUTE_ID = 23L;
+    private static final long MIN_P_I_N_CODE_LENGTH_ATTRIBUTE_ID = 24L;
+    private static final long MAX_R_F_I_D_CODE_LENGTH_ATTRIBUTE_ID = 25L;
+    private static final long MIN_R_F_I_D_CODE_LENGTH_ATTRIBUTE_ID = 26L;
+    private static final long CREDENTIAL_RULES_SUPPORT_ATTRIBUTE_ID = 27L;
+    private static final long NUMBER_OF_CREDENTIALS_SUPPORTED_PER_USER_ATTRIBUTE_ID = 28L;
+    private static final long LANGUAGE_ATTRIBUTE_ID = 33L;
+    private static final long L_E_D_SETTINGS_ATTRIBUTE_ID = 34L;
+    private static final long AUTO_RELOCK_TIME_ATTRIBUTE_ID = 35L;
+    private static final long SOUND_VOLUME_ATTRIBUTE_ID = 36L;
+    private static final long OPERATING_MODE_ATTRIBUTE_ID = 37L;
+    private static final long SUPPORTED_OPERATING_MODES_ATTRIBUTE_ID = 38L;
+    private static final long DEFAULT_CONFIGURATION_REGISTER_ATTRIBUTE_ID = 39L;
+    private static final long ENABLE_LOCAL_PROGRAMMING_ATTRIBUTE_ID = 40L;
+    private static final long ENABLE_ONE_TOUCH_LOCKING_ATTRIBUTE_ID = 41L;
+    private static final long ENABLE_INSIDE_STATUS_L_E_D_ATTRIBUTE_ID = 42L;
+    private static final long ENABLE_PRIVACY_MODE_BUTTON_ATTRIBUTE_ID = 43L;
+    private static final long LOCAL_PROGRAMMING_FEATURES_ATTRIBUTE_ID = 44L;
+    private static final long WRONG_CODE_ENTRY_LIMIT_ATTRIBUTE_ID = 48L;
+    private static final long USER_CODE_TEMPORARY_DISABLE_TIME_ATTRIBUTE_ID = 49L;
+    private static final long SEND_P_I_N_OVER_THE_AIR_ATTRIBUTE_ID = 50L;
+    private static final long REQUIRE_P_I_NFOR_REMOTE_OPERATION_ATTRIBUTE_ID = 51L;
+    private static final long EXPIRING_USER_TIMEOUT_ATTRIBUTE_ID = 53L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
 
-    private native void readReplacementProductListAttribute(long chipClusterPtr, ReplacementProductListAttributeCallback callback);
+    public DoorLockCluster(long devicePtr, int endpointId) {
+      super(devicePtr, endpointId, CLUSTER_ID);
+    }
 
-    private native void subscribeReplacementProductListAttribute(long chipClusterPtr, ReplacementProductListAttributeCallback callback, int minInterval, int maxInterval);
+    @Override
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
 
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+    public void lockDoor(DefaultClusterCallback callback, Optional<byte[]> PINCode, int timedInvokeTimeoutMs) {
+      final long commandId = 0L;
 
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long PINCodeFieldID = 0L;
+      BaseTLVType PINCodetlvValue = PINCode.<BaseTLVType>map((nonOptionalPINCode) -> new ByteArrayType(nonOptionalPINCode)).orElse(new EmptyType());
+      elements.add(new StructElement(PINCodeFieldID, PINCodetlvValue));
 
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
 
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
+    public void unlockDoor(DefaultClusterCallback callback, Optional<byte[]> PINCode, int timedInvokeTimeoutMs) {
+      final long commandId = 1L;
 
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long PINCodeFieldID = 0L;
+      BaseTLVType PINCodetlvValue = PINCode.<BaseTLVType>map((nonOptionalPINCode) -> new ByteArrayType(nonOptionalPINCode)).orElse(new EmptyType());
+      elements.add(new StructElement(PINCodeFieldID, PINCodetlvValue));
 
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
 
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+    public void unlockWithTimeout(DefaultClusterCallback callback, Integer timeout, Optional<byte[]> PINCode, int timedInvokeTimeoutMs) {
+      final long commandId = 3L;
 
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long timeoutFieldID = 0L;
+      BaseTLVType timeouttlvValue = new UIntType(timeout);
+      elements.add(new StructElement(timeoutFieldID, timeouttlvValue));
 
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-  }
+      final long PINCodeFieldID = 1L;
+      BaseTLVType PINCodetlvValue = PINCode.<BaseTLVType>map((nonOptionalPINCode) -> new ByteArrayType(nonOptionalPINCode)).orElse(new EmptyType());
+      elements.add(new StructElement(PINCodeFieldID, PINCodetlvValue));
 
-  public static class DoorLockCluster extends BaseChipCluster {
-    public static final long CLUSTER_ID = 257L;
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public DoorLockCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+    public void setWeekDaySchedule(DefaultClusterCallback callback, Integer weekDayIndex, Integer userIndex, Integer daysMask, Integer startHour, Integer startMinute, Integer endHour, Integer endMinute) {
+      setWeekDaySchedule(callback, weekDayIndex, userIndex, daysMask, startHour, startMinute, endHour, endMinute, 0);
     }
 
-    @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    public void setWeekDaySchedule(DefaultClusterCallback callback, Integer weekDayIndex, Integer userIndex, Integer daysMask, Integer startHour, Integer startMinute, Integer endHour, Integer endMinute, int timedInvokeTimeoutMs) {
+      final long commandId = 11L;
 
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long weekDayIndexFieldID = 0L;
+      BaseTLVType weekDayIndextlvValue = new UIntType(weekDayIndex);
+      elements.add(new StructElement(weekDayIndexFieldID, weekDayIndextlvValue));
 
-    public void lockDoor(DefaultClusterCallback callback, Optional<byte[]> PINCode, int timedInvokeTimeoutMs) {
-      lockDoor(chipClusterPtr, callback, PINCode, timedInvokeTimeoutMs);
-    }
+      final long userIndexFieldID = 1L;
+      BaseTLVType userIndextlvValue = new UIntType(userIndex);
+      elements.add(new StructElement(userIndexFieldID, userIndextlvValue));
 
+      final long daysMaskFieldID = 2L;
+      BaseTLVType daysMasktlvValue = new UIntType(daysMask);
+      elements.add(new StructElement(daysMaskFieldID, daysMasktlvValue));
 
-    public void unlockDoor(DefaultClusterCallback callback, Optional<byte[]> PINCode, int timedInvokeTimeoutMs) {
-      unlockDoor(chipClusterPtr, callback, PINCode, timedInvokeTimeoutMs);
-    }
+      final long startHourFieldID = 3L;
+      BaseTLVType startHourtlvValue = new UIntType(startHour);
+      elements.add(new StructElement(startHourFieldID, startHourtlvValue));
 
+      final long startMinuteFieldID = 4L;
+      BaseTLVType startMinutetlvValue = new UIntType(startMinute);
+      elements.add(new StructElement(startMinuteFieldID, startMinutetlvValue));
 
-    public void unlockWithTimeout(DefaultClusterCallback callback, Integer timeout, Optional<byte[]> PINCode, int timedInvokeTimeoutMs) {
-      unlockWithTimeout(chipClusterPtr, callback, timeout, PINCode, timedInvokeTimeoutMs);
-    }
+      final long endHourFieldID = 5L;
+      BaseTLVType endHourtlvValue = new UIntType(endHour);
+      elements.add(new StructElement(endHourFieldID, endHourtlvValue));
 
-    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);
-    }
+      final long endMinuteFieldID = 6L;
+      BaseTLVType endMinutetlvValue = new UIntType(endMinute);
+      elements.add(new StructElement(endMinuteFieldID, endMinutetlvValue));
 
-    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);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void getWeekDaySchedule(GetWeekDayScheduleResponseCallback callback, Integer weekDayIndex, Integer userIndex) {
-      getWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, null);
+      getWeekDaySchedule(callback, weekDayIndex, userIndex, 0);
     }
 
     public void getWeekDaySchedule(GetWeekDayScheduleResponseCallback callback, Integer weekDayIndex, Integer userIndex, int timedInvokeTimeoutMs) {
-      getWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, timedInvokeTimeoutMs);
+      final long commandId = 12L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long weekDayIndexFieldID = 0L;
+      BaseTLVType weekDayIndextlvValue = new UIntType(weekDayIndex);
+      elements.add(new StructElement(weekDayIndexFieldID, weekDayIndextlvValue));
+
+      final long userIndexFieldID = 1L;
+      BaseTLVType userIndextlvValue = new UIntType(userIndex);
+      elements.add(new StructElement(userIndexFieldID, userIndextlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long weekDayIndexFieldID = 0L;
+          Integer weekDayIndex = null;
+          final long userIndexFieldID = 1L;
+          Integer userIndex = null;
+          final long statusFieldID = 2L;
+          Integer status = null;
+          final long daysMaskFieldID = 3L;
+          Optional<Integer> daysMask = Optional.empty();
+          final long startHourFieldID = 4L;
+          Optional<Integer> startHour = Optional.empty();
+          final long startMinuteFieldID = 5L;
+          Optional<Integer> startMinute = Optional.empty();
+          final long endHourFieldID = 6L;
+          Optional<Integer> endHour = Optional.empty();
+          final long endMinuteFieldID = 7L;
+          Optional<Integer> endMinute = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == weekDayIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                weekDayIndex = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == userIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                userIndex = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == daysMaskFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                daysMask = Optional.of(castingValue.value(Integer.class));
+              }
+            } else if (element.contextTagNum() == startHourFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                startHour = Optional.of(castingValue.value(Integer.class));
+              }
+            } else if (element.contextTagNum() == startMinuteFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                startMinute = Optional.of(castingValue.value(Integer.class));
+              }
+            } else if (element.contextTagNum() == endHourFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                endHour = Optional.of(castingValue.value(Integer.class));
+              }
+            } else if (element.contextTagNum() == endMinuteFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                endMinute = Optional.of(castingValue.value(Integer.class));
+              }
+            }
+          }
+          callback.onSuccess(weekDayIndex, userIndex, status, daysMask, startHour, startMinute, endHour, endMinute);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void clearWeekDaySchedule(DefaultClusterCallback callback, Integer weekDayIndex, Integer userIndex) {
-      clearWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, null);
+      clearWeekDaySchedule(callback, weekDayIndex, userIndex, 0);
     }
 
     public void clearWeekDaySchedule(DefaultClusterCallback callback, Integer weekDayIndex, Integer userIndex, int timedInvokeTimeoutMs) {
-      clearWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, timedInvokeTimeoutMs);
+      final long commandId = 13L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long weekDayIndexFieldID = 0L;
+      BaseTLVType weekDayIndextlvValue = new UIntType(weekDayIndex);
+      elements.add(new StructElement(weekDayIndexFieldID, weekDayIndextlvValue));
+
+      final long userIndexFieldID = 1L;
+      BaseTLVType userIndextlvValue = new UIntType(userIndex);
+      elements.add(new StructElement(userIndexFieldID, userIndextlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void setYearDaySchedule(DefaultClusterCallback callback, Integer yearDayIndex, Integer userIndex, Long localStartTime, Long localEndTime) {
-      setYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, localStartTime, localEndTime, null);
+      setYearDaySchedule(callback, yearDayIndex, userIndex, localStartTime, localEndTime, 0);
     }
 
     public void setYearDaySchedule(DefaultClusterCallback callback, Integer yearDayIndex, Integer userIndex, Long localStartTime, Long localEndTime, int timedInvokeTimeoutMs) {
-      setYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, localStartTime, localEndTime, timedInvokeTimeoutMs);
+      final long commandId = 14L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long yearDayIndexFieldID = 0L;
+      BaseTLVType yearDayIndextlvValue = new UIntType(yearDayIndex);
+      elements.add(new StructElement(yearDayIndexFieldID, yearDayIndextlvValue));
+
+      final long userIndexFieldID = 1L;
+      BaseTLVType userIndextlvValue = new UIntType(userIndex);
+      elements.add(new StructElement(userIndexFieldID, userIndextlvValue));
+
+      final long localStartTimeFieldID = 2L;
+      BaseTLVType localStartTimetlvValue = new UIntType(localStartTime);
+      elements.add(new StructElement(localStartTimeFieldID, localStartTimetlvValue));
+
+      final long localEndTimeFieldID = 3L;
+      BaseTLVType localEndTimetlvValue = new UIntType(localEndTime);
+      elements.add(new StructElement(localEndTimeFieldID, localEndTimetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void getYearDaySchedule(GetYearDayScheduleResponseCallback callback, Integer yearDayIndex, Integer userIndex) {
-      getYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, null);
+      getYearDaySchedule(callback, yearDayIndex, userIndex, 0);
     }
 
     public void getYearDaySchedule(GetYearDayScheduleResponseCallback callback, Integer yearDayIndex, Integer userIndex, int timedInvokeTimeoutMs) {
-      getYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, timedInvokeTimeoutMs);
+      final long commandId = 15L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long yearDayIndexFieldID = 0L;
+      BaseTLVType yearDayIndextlvValue = new UIntType(yearDayIndex);
+      elements.add(new StructElement(yearDayIndexFieldID, yearDayIndextlvValue));
+
+      final long userIndexFieldID = 1L;
+      BaseTLVType userIndextlvValue = new UIntType(userIndex);
+      elements.add(new StructElement(userIndexFieldID, userIndextlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long yearDayIndexFieldID = 0L;
+          Integer yearDayIndex = null;
+          final long userIndexFieldID = 1L;
+          Integer userIndex = null;
+          final long statusFieldID = 2L;
+          Integer status = null;
+          final long localStartTimeFieldID = 3L;
+          Optional<Long> localStartTime = Optional.empty();
+          final long localEndTimeFieldID = 4L;
+          Optional<Long> localEndTime = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == yearDayIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                yearDayIndex = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == userIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                userIndex = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == localStartTimeFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                localStartTime = Optional.of(castingValue.value(Long.class));
+              }
+            } else if (element.contextTagNum() == localEndTimeFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                localEndTime = Optional.of(castingValue.value(Long.class));
+              }
+            }
+          }
+          callback.onSuccess(yearDayIndex, userIndex, status, localStartTime, localEndTime);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void clearYearDaySchedule(DefaultClusterCallback callback, Integer yearDayIndex, Integer userIndex) {
-      clearYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, null);
+      clearYearDaySchedule(callback, yearDayIndex, userIndex, 0);
     }
 
     public void clearYearDaySchedule(DefaultClusterCallback callback, Integer yearDayIndex, Integer userIndex, int timedInvokeTimeoutMs) {
-      clearYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, timedInvokeTimeoutMs);
+      final long commandId = 16L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long yearDayIndexFieldID = 0L;
+      BaseTLVType yearDayIndextlvValue = new UIntType(yearDayIndex);
+      elements.add(new StructElement(yearDayIndexFieldID, yearDayIndextlvValue));
+
+      final long userIndexFieldID = 1L;
+      BaseTLVType userIndextlvValue = new UIntType(userIndex);
+      elements.add(new StructElement(userIndexFieldID, userIndextlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void setHolidaySchedule(DefaultClusterCallback callback, Integer holidayIndex, Long localStartTime, Long localEndTime, Integer operatingMode) {
-      setHolidaySchedule(chipClusterPtr, callback, holidayIndex, localStartTime, localEndTime, operatingMode, null);
+      setHolidaySchedule(callback, holidayIndex, localStartTime, localEndTime, operatingMode, 0);
     }
 
     public void setHolidaySchedule(DefaultClusterCallback callback, Integer holidayIndex, Long localStartTime, Long localEndTime, Integer operatingMode, int timedInvokeTimeoutMs) {
-      setHolidaySchedule(chipClusterPtr, callback, holidayIndex, localStartTime, localEndTime, operatingMode, timedInvokeTimeoutMs);
+      final long commandId = 17L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long holidayIndexFieldID = 0L;
+      BaseTLVType holidayIndextlvValue = new UIntType(holidayIndex);
+      elements.add(new StructElement(holidayIndexFieldID, holidayIndextlvValue));
+
+      final long localStartTimeFieldID = 1L;
+      BaseTLVType localStartTimetlvValue = new UIntType(localStartTime);
+      elements.add(new StructElement(localStartTimeFieldID, localStartTimetlvValue));
+
+      final long localEndTimeFieldID = 2L;
+      BaseTLVType localEndTimetlvValue = new UIntType(localEndTime);
+      elements.add(new StructElement(localEndTimeFieldID, localEndTimetlvValue));
+
+      final long operatingModeFieldID = 3L;
+      BaseTLVType operatingModetlvValue = new UIntType(operatingMode);
+      elements.add(new StructElement(operatingModeFieldID, operatingModetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void getHolidaySchedule(GetHolidayScheduleResponseCallback callback, Integer holidayIndex) {
-      getHolidaySchedule(chipClusterPtr, callback, holidayIndex, null);
+      getHolidaySchedule(callback, holidayIndex, 0);
     }
 
     public void getHolidaySchedule(GetHolidayScheduleResponseCallback callback, Integer holidayIndex, int timedInvokeTimeoutMs) {
-      getHolidaySchedule(chipClusterPtr, callback, holidayIndex, timedInvokeTimeoutMs);
+      final long commandId = 18L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long holidayIndexFieldID = 0L;
+      BaseTLVType holidayIndextlvValue = new UIntType(holidayIndex);
+      elements.add(new StructElement(holidayIndexFieldID, holidayIndextlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long holidayIndexFieldID = 0L;
+          Integer holidayIndex = null;
+          final long statusFieldID = 1L;
+          Integer status = null;
+          final long localStartTimeFieldID = 2L;
+          Optional<Long> localStartTime = Optional.empty();
+          final long localEndTimeFieldID = 3L;
+          Optional<Long> localEndTime = Optional.empty();
+          final long operatingModeFieldID = 4L;
+          Optional<Integer> operatingMode = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == holidayIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                holidayIndex = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == localStartTimeFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                localStartTime = Optional.of(castingValue.value(Long.class));
+              }
+            } else if (element.contextTagNum() == localEndTimeFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                localEndTime = Optional.of(castingValue.value(Long.class));
+              }
+            } else if (element.contextTagNum() == operatingModeFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                operatingMode = Optional.of(castingValue.value(Integer.class));
+              }
+            }
+          }
+          callback.onSuccess(holidayIndex, status, localStartTime, localEndTime, operatingMode);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void clearHolidaySchedule(DefaultClusterCallback callback, Integer holidayIndex) {
-      clearHolidaySchedule(chipClusterPtr, callback, holidayIndex, null);
+      clearHolidaySchedule(callback, holidayIndex, 0);
     }
 
     public void clearHolidaySchedule(DefaultClusterCallback callback, Integer holidayIndex, int timedInvokeTimeoutMs) {
-      clearHolidaySchedule(chipClusterPtr, callback, holidayIndex, timedInvokeTimeoutMs);
+      final long commandId = 19L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long holidayIndexFieldID = 0L;
+      BaseTLVType holidayIndextlvValue = new UIntType(holidayIndex);
+      elements.add(new StructElement(holidayIndexFieldID, holidayIndextlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, 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);
+      final long commandId = 26L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long operationTypeFieldID = 0L;
+      BaseTLVType operationTypetlvValue = new UIntType(operationType);
+      elements.add(new StructElement(operationTypeFieldID, operationTypetlvValue));
+
+      final long userIndexFieldID = 1L;
+      BaseTLVType userIndextlvValue = new UIntType(userIndex);
+      elements.add(new StructElement(userIndexFieldID, userIndextlvValue));
+
+      final long userNameFieldID = 2L;
+      BaseTLVType userNametlvValue = userName != null ? new StringType(userName) : new NullType();
+      elements.add(new StructElement(userNameFieldID, userNametlvValue));
+
+      final long userUniqueIDFieldID = 3L;
+      BaseTLVType userUniqueIDtlvValue = userUniqueID != null ? new UIntType(userUniqueID) : new NullType();
+      elements.add(new StructElement(userUniqueIDFieldID, userUniqueIDtlvValue));
+
+      final long userStatusFieldID = 4L;
+      BaseTLVType userStatustlvValue = userStatus != null ? new UIntType(userStatus) : new NullType();
+      elements.add(new StructElement(userStatusFieldID, userStatustlvValue));
+
+      final long userTypeFieldID = 5L;
+      BaseTLVType userTypetlvValue = userType != null ? new UIntType(userType) : new NullType();
+      elements.add(new StructElement(userTypeFieldID, userTypetlvValue));
+
+      final long credentialRuleFieldID = 6L;
+      BaseTLVType credentialRuletlvValue = credentialRule != null ? new UIntType(credentialRule) : new NullType();
+      elements.add(new StructElement(credentialRuleFieldID, credentialRuletlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void getUser(GetUserResponseCallback callback, Integer userIndex) {
-      getUser(chipClusterPtr, callback, userIndex, null);
+      getUser(callback, userIndex, 0);
     }
 
     public void getUser(GetUserResponseCallback callback, Integer userIndex, int timedInvokeTimeoutMs) {
-      getUser(chipClusterPtr, callback, userIndex, timedInvokeTimeoutMs);
+      final long commandId = 27L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long userIndexFieldID = 0L;
+      BaseTLVType userIndextlvValue = new UIntType(userIndex);
+      elements.add(new StructElement(userIndexFieldID, userIndextlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long userIndexFieldID = 0L;
+          Integer userIndex = null;
+          final long userNameFieldID = 1L;
+          @Nullable String userName = null;
+          final long userUniqueIDFieldID = 2L;
+          @Nullable Long userUniqueID = null;
+          final long userStatusFieldID = 3L;
+          @Nullable Integer userStatus = null;
+          final long userTypeFieldID = 4L;
+          @Nullable Integer userType = null;
+          final long credentialRuleFieldID = 5L;
+          @Nullable Integer credentialRule = null;
+          final long credentialsFieldID = 6L;
+          @Nullable ArrayList<ChipStructs.DoorLockClusterCredentialStruct> credentials = null;
+          final long creatorFabricIndexFieldID = 7L;
+          @Nullable Integer creatorFabricIndex = null;
+          final long lastModifiedFabricIndexFieldID = 8L;
+          @Nullable Integer lastModifiedFabricIndex = null;
+          final long nextUserIndexFieldID = 9L;
+          @Nullable Integer nextUserIndex = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == userIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                userIndex = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == userNameFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                userName = castingValue.value(String.class);
+              }
+            } else if (element.contextTagNum() == userUniqueIDFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                userUniqueID = castingValue.value(Long.class);
+              }
+            } else if (element.contextTagNum() == userStatusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                userStatus = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == userTypeFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                userType = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == credentialRuleFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                credentialRule = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == credentialsFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+                ArrayType castingValue = element.value(ArrayType.class);
+                credentials = castingValue.map((elementcastingValue) -> ChipStructs.DoorLockClusterCredentialStruct.decodeTlv(elementcastingValue));
+              }
+            } else if (element.contextTagNum() == creatorFabricIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                creatorFabricIndex = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == lastModifiedFabricIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                lastModifiedFabricIndex = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == nextUserIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                nextUserIndex = castingValue.value(Integer.class);
+              }
+            }
+          }
+          callback.onSuccess(userIndex, userName, userUniqueID, userStatus, userType, credentialRule, credentials, creatorFabricIndex, lastModifiedFabricIndex, nextUserIndex);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
 
     public void clearUser(DefaultClusterCallback callback, Integer userIndex, int timedInvokeTimeoutMs) {
-      clearUser(chipClusterPtr, callback, userIndex, timedInvokeTimeoutMs);
+      final long commandId = 29L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long userIndexFieldID = 0L;
+      BaseTLVType userIndextlvValue = new UIntType(userIndex);
+      elements.add(new StructElement(userIndexFieldID, userIndextlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
 
     public void setCredential(SetCredentialResponseCallback callback, Integer operationType, ChipStructs.DoorLockClusterCredentialStruct credential, byte[] credentialData, @Nullable Integer userIndex, @Nullable Integer userStatus, @Nullable Integer userType, int timedInvokeTimeoutMs) {
-      setCredential(chipClusterPtr, callback, operationType, credential, credentialData, userIndex, userStatus, userType, timedInvokeTimeoutMs);
+      final long commandId = 34L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long operationTypeFieldID = 0L;
+      BaseTLVType operationTypetlvValue = new UIntType(operationType);
+      elements.add(new StructElement(operationTypeFieldID, operationTypetlvValue));
+
+      final long credentialFieldID = 1L;
+      BaseTLVType credentialtlvValue = credential.encodeTlv();
+      elements.add(new StructElement(credentialFieldID, credentialtlvValue));
+
+      final long credentialDataFieldID = 2L;
+      BaseTLVType credentialDatatlvValue = new ByteArrayType(credentialData);
+      elements.add(new StructElement(credentialDataFieldID, credentialDatatlvValue));
+
+      final long userIndexFieldID = 3L;
+      BaseTLVType userIndextlvValue = userIndex != null ? new UIntType(userIndex) : new NullType();
+      elements.add(new StructElement(userIndexFieldID, userIndextlvValue));
+
+      final long userStatusFieldID = 4L;
+      BaseTLVType userStatustlvValue = userStatus != null ? new UIntType(userStatus) : new NullType();
+      elements.add(new StructElement(userStatusFieldID, userStatustlvValue));
+
+      final long userTypeFieldID = 5L;
+      BaseTLVType userTypetlvValue = userType != null ? new UIntType(userType) : new NullType();
+      elements.add(new StructElement(userTypeFieldID, userTypetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long userIndexFieldID = 1L;
+          @Nullable Integer userIndex = null;
+          final long nextCredentialIndexFieldID = 2L;
+          @Nullable Integer nextCredentialIndex = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == userIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                userIndex = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == nextCredentialIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                nextCredentialIndex = castingValue.value(Integer.class);
+              }
+            }
+          }
+          callback.onSuccess(status, userIndex, nextCredentialIndex);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void getCredentialStatus(GetCredentialStatusResponseCallback callback, ChipStructs.DoorLockClusterCredentialStruct credential) {
-      getCredentialStatus(chipClusterPtr, callback, credential, null);
+      getCredentialStatus(callback, credential, 0);
     }
 
     public void getCredentialStatus(GetCredentialStatusResponseCallback callback, ChipStructs.DoorLockClusterCredentialStruct credential, int timedInvokeTimeoutMs) {
-      getCredentialStatus(chipClusterPtr, callback, credential, timedInvokeTimeoutMs);
+      final long commandId = 36L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long credentialFieldID = 0L;
+      BaseTLVType credentialtlvValue = credential.encodeTlv();
+      elements.add(new StructElement(credentialFieldID, credentialtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long credentialExistsFieldID = 0L;
+          Boolean credentialExists = null;
+          final long userIndexFieldID = 1L;
+          @Nullable Integer userIndex = null;
+          final long creatorFabricIndexFieldID = 2L;
+          @Nullable Integer creatorFabricIndex = null;
+          final long lastModifiedFabricIndexFieldID = 3L;
+          @Nullable Integer lastModifiedFabricIndex = null;
+          final long nextCredentialIndexFieldID = 4L;
+          @Nullable Integer nextCredentialIndex = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == credentialExistsFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                credentialExists = castingValue.value(Boolean.class);
+              }
+            } else if (element.contextTagNum() == userIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                userIndex = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == creatorFabricIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                creatorFabricIndex = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == lastModifiedFabricIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                lastModifiedFabricIndex = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == nextCredentialIndexFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                nextCredentialIndex = castingValue.value(Integer.class);
+              }
+            }
+          }
+          callback.onSuccess(credentialExists, userIndex, creatorFabricIndex, lastModifiedFabricIndex, nextCredentialIndex);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
 
     public void clearCredential(DefaultClusterCallback callback, @Nullable ChipStructs.DoorLockClusterCredentialStruct credential, int timedInvokeTimeoutMs) {
-      clearCredential(chipClusterPtr, callback, credential, timedInvokeTimeoutMs);
-    }
+      final long commandId = 38L;
 
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long credentialFieldID = 0L;
+      BaseTLVType credentialtlvValue = credential != null ? credential.encodeTlv() : new NullType();
+      elements.add(new StructElement(credentialFieldID, credentialtlvValue));
 
-    public void unboltDoor(DefaultClusterCallback callback, Optional<byte[]> PINCode, int timedInvokeTimeoutMs) {
-      unboltDoor(chipClusterPtr, callback, PINCode, timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
-    private native void lockDoor(long chipClusterPtr, DefaultClusterCallback callback, Optional<byte[]> PINCode, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void unlockDoor(long chipClusterPtr, DefaultClusterCallback callback, Optional<byte[]> PINCode, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void unlockWithTimeout(long chipClusterPtr, DefaultClusterCallback callback, Integer timeout, Optional<byte[]> PINCode, @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 getWeekDaySchedule(long chipClusterPtr, GetWeekDayScheduleResponseCallback callback, Integer weekDayIndex, Integer userIndex, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void clearWeekDaySchedule(long chipClusterPtr, DefaultClusterCallback callback, Integer weekDayIndex, Integer userIndex, @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 getYearDaySchedule(long chipClusterPtr, GetYearDayScheduleResponseCallback callback, Integer yearDayIndex, Integer userIndex, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void clearYearDaySchedule(long chipClusterPtr, DefaultClusterCallback callback, Integer yearDayIndex, Integer userIndex, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void setHolidaySchedule(long chipClusterPtr, DefaultClusterCallback callback, Integer holidayIndex, Long localStartTime, Long localEndTime, Integer operatingMode, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void getHolidaySchedule(long chipClusterPtr, GetHolidayScheduleResponseCallback callback, Integer holidayIndex, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void clearHolidaySchedule(long chipClusterPtr, DefaultClusterCallback callback, Integer holidayIndex, @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 getUser(long chipClusterPtr, GetUserResponseCallback callback, Integer userIndex, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void clearUser(long chipClusterPtr, DefaultClusterCallback callback, Integer userIndex, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void setCredential(long chipClusterPtr, SetCredentialResponseCallback callback, Integer operationType, ChipStructs.DoorLockClusterCredentialStruct credential, byte[] credentialData, @Nullable Integer userIndex, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void getCredentialStatus(long chipClusterPtr, GetCredentialStatusResponseCallback callback, ChipStructs.DoorLockClusterCredentialStruct credential, @Nullable Integer timedInvokeTimeoutMs);
+    public void unboltDoor(DefaultClusterCallback callback, Optional<byte[]> PINCode, int timedInvokeTimeoutMs) {
+      final long commandId = 39L;
 
-    private native void clearCredential(long chipClusterPtr, DefaultClusterCallback callback, @Nullable ChipStructs.DoorLockClusterCredentialStruct credential, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long PINCodeFieldID = 0L;
+      BaseTLVType PINCodetlvValue = PINCode.<BaseTLVType>map((nonOptionalPINCode) -> new ByteArrayType(nonOptionalPINCode)).orElse(new EmptyType());
+      elements.add(new StructElement(PINCodeFieldID, PINCodetlvValue));
 
-    private native void unboltDoor(long chipClusterPtr, DefaultClusterCallback callback, Optional<byte[]> PINCode, @Nullable Integer timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface GetWeekDayScheduleResponseCallback {
+    public interface GetWeekDayScheduleResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer weekDayIndex, Integer userIndex, Integer status, Optional<Integer> daysMask, Optional<Integer> startHour, Optional<Integer> startMinute, Optional<Integer> endHour, Optional<Integer> endMinute);
-      void onError(Exception error);
     }
 
-    public interface GetYearDayScheduleResponseCallback {
+    public interface GetYearDayScheduleResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer yearDayIndex, Integer userIndex, Integer status, Optional<Long> localStartTime, Optional<Long> localEndTime);
-      void onError(Exception error);
     }
 
-    public interface GetHolidayScheduleResponseCallback {
+    public interface GetHolidayScheduleResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer holidayIndex, Integer status, Optional<Long> localStartTime, Optional<Long> localEndTime, Optional<Integer> operatingMode);
-      void onError(Exception error);
     }
 
-    public interface GetUserResponseCallback {
+    public interface GetUserResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer userIndex, @Nullable String userName, @Nullable Long userUniqueID, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule, @Nullable ArrayList<ChipStructs.DoorLockClusterCredentialStruct> credentials, @Nullable Integer creatorFabricIndex, @Nullable Integer lastModifiedFabricIndex, @Nullable Integer nextUserIndex);
-      void onError(Exception error);
     }
 
-    public interface SetCredentialResponseCallback {
+    public interface SetCredentialResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex);
-      void onError(Exception error);
     }
 
-    public interface GetCredentialStatusResponseCallback {
+    public interface GetCredentialStatusResponseCallback extends BaseClusterCallback {
       void onSuccess(Boolean credentialExists, @Nullable Integer userIndex, @Nullable Integer creatorFabricIndex, @Nullable Integer lastModifiedFabricIndex, @Nullable Integer nextCredentialIndex);
-      void onError(Exception error);
     }
 
-    public interface LockStateAttributeCallback {
+    public interface LockStateAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface DoorStateAttributeCallback {
+    public interface DoorStateAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readLockStateAttribute(
         LockStateAttributeCallback callback) {
-        readLockStateAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOCK_STATE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LOCK_STATE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLockStateAttribute(
         LockStateAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLockStateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOCK_STATE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LOCK_STATE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLockTypeAttribute(
         IntegerAttributeCallback callback) {
-        readLockTypeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOCK_TYPE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LOCK_TYPE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLockTypeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLockTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOCK_TYPE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LOCK_TYPE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActuatorEnabledAttribute(
         BooleanAttributeCallback callback) {
-        readActuatorEnabledAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTUATOR_ENABLED_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTUATOR_ENABLED_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActuatorEnabledAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActuatorEnabledAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTUATOR_ENABLED_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTUATOR_ENABLED_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDoorStateAttribute(
         DoorStateAttributeCallback callback) {
-        readDoorStateAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DOOR_STATE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DOOR_STATE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDoorStateAttribute(
         DoorStateAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDoorStateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DOOR_STATE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DOOR_STATE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDoorOpenEventsAttribute(
         LongAttributeCallback callback) {
-        readDoorOpenEventsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DOOR_OPEN_EVENTS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DOOR_OPEN_EVENTS_ATTRIBUTE_ID, true);
     }
 
     public void writeDoorOpenEventsAttribute(DefaultClusterCallback callback, Long value) {
-        writeDoorOpenEventsAttribute(chipClusterPtr, callback, value, null);
+      writeDoorOpenEventsAttribute(callback, value, 0);
     }
 
     public void writeDoorOpenEventsAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeDoorOpenEventsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), DOOR_OPEN_EVENTS_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeDoorOpenEventsAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDoorOpenEventsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DOOR_OPEN_EVENTS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DOOR_OPEN_EVENTS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDoorClosedEventsAttribute(
         LongAttributeCallback callback) {
-        readDoorClosedEventsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DOOR_CLOSED_EVENTS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DOOR_CLOSED_EVENTS_ATTRIBUTE_ID, true);
     }
 
     public void writeDoorClosedEventsAttribute(DefaultClusterCallback callback, Long value) {
-        writeDoorClosedEventsAttribute(chipClusterPtr, callback, value, null);
+      writeDoorClosedEventsAttribute(callback, value, 0);
     }
 
     public void writeDoorClosedEventsAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeDoorClosedEventsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), DOOR_CLOSED_EVENTS_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeDoorClosedEventsAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDoorClosedEventsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DOOR_CLOSED_EVENTS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DOOR_CLOSED_EVENTS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOpenPeriodAttribute(
         IntegerAttributeCallback callback) {
-        readOpenPeriodAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPEN_PERIOD_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OPEN_PERIOD_ATTRIBUTE_ID, true);
     }
 
     public void writeOpenPeriodAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOpenPeriodAttribute(chipClusterPtr, callback, value, null);
+      writeOpenPeriodAttribute(callback, value, 0);
     }
 
     public void writeOpenPeriodAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOpenPeriodAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), OPEN_PERIOD_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOpenPeriodAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOpenPeriodAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPEN_PERIOD_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OPEN_PERIOD_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readNumberOfTotalUsersSupportedAttribute(
         IntegerAttributeCallback callback) {
-        readNumberOfTotalUsersSupportedAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_TOTAL_USERS_SUPPORTED_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NUMBER_OF_TOTAL_USERS_SUPPORTED_ATTRIBUTE_ID, true);
     }
 
     public void subscribeNumberOfTotalUsersSupportedAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNumberOfTotalUsersSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_TOTAL_USERS_SUPPORTED_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NUMBER_OF_TOTAL_USERS_SUPPORTED_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readNumberOfPINUsersSupportedAttribute(
         IntegerAttributeCallback callback) {
-        readNumberOfPINUsersSupportedAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_P_I_N_USERS_SUPPORTED_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NUMBER_OF_P_I_N_USERS_SUPPORTED_ATTRIBUTE_ID, true);
     }
 
     public void subscribeNumberOfPINUsersSupportedAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNumberOfPINUsersSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_P_I_N_USERS_SUPPORTED_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NUMBER_OF_P_I_N_USERS_SUPPORTED_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readNumberOfRFIDUsersSupportedAttribute(
         IntegerAttributeCallback callback) {
-        readNumberOfRFIDUsersSupportedAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_R_F_I_D_USERS_SUPPORTED_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NUMBER_OF_R_F_I_D_USERS_SUPPORTED_ATTRIBUTE_ID, true);
     }
 
     public void subscribeNumberOfRFIDUsersSupportedAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNumberOfRFIDUsersSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_R_F_I_D_USERS_SUPPORTED_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NUMBER_OF_R_F_I_D_USERS_SUPPORTED_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readNumberOfWeekDaySchedulesSupportedPerUserAttribute(
         IntegerAttributeCallback callback) {
-        readNumberOfWeekDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_WEEK_DAY_SCHEDULES_SUPPORTED_PER_USER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NUMBER_OF_WEEK_DAY_SCHEDULES_SUPPORTED_PER_USER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_WEEK_DAY_SCHEDULES_SUPPORTED_PER_USER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NUMBER_OF_WEEK_DAY_SCHEDULES_SUPPORTED_PER_USER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readNumberOfYearDaySchedulesSupportedPerUserAttribute(
         IntegerAttributeCallback callback) {
-        readNumberOfYearDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_YEAR_DAY_SCHEDULES_SUPPORTED_PER_USER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NUMBER_OF_YEAR_DAY_SCHEDULES_SUPPORTED_PER_USER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_YEAR_DAY_SCHEDULES_SUPPORTED_PER_USER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NUMBER_OF_YEAR_DAY_SCHEDULES_SUPPORTED_PER_USER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readNumberOfHolidaySchedulesSupportedAttribute(
         IntegerAttributeCallback callback) {
-        readNumberOfHolidaySchedulesSupportedAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_HOLIDAY_SCHEDULES_SUPPORTED_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NUMBER_OF_HOLIDAY_SCHEDULES_SUPPORTED_ATTRIBUTE_ID, true);
     }
 
     public void subscribeNumberOfHolidaySchedulesSupportedAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNumberOfHolidaySchedulesSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_HOLIDAY_SCHEDULES_SUPPORTED_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NUMBER_OF_HOLIDAY_SCHEDULES_SUPPORTED_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxPINCodeLengthAttribute(
         IntegerAttributeCallback callback) {
-        readMaxPINCodeLengthAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_P_I_N_CODE_LENGTH_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_P_I_N_CODE_LENGTH_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxPINCodeLengthAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxPINCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_P_I_N_CODE_LENGTH_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_P_I_N_CODE_LENGTH_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinPINCodeLengthAttribute(
         IntegerAttributeCallback callback) {
-        readMinPINCodeLengthAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_P_I_N_CODE_LENGTH_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_P_I_N_CODE_LENGTH_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinPINCodeLengthAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinPINCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_P_I_N_CODE_LENGTH_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_P_I_N_CODE_LENGTH_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxRFIDCodeLengthAttribute(
         IntegerAttributeCallback callback) {
-        readMaxRFIDCodeLengthAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_R_F_I_D_CODE_LENGTH_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_R_F_I_D_CODE_LENGTH_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxRFIDCodeLengthAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxRFIDCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_R_F_I_D_CODE_LENGTH_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_R_F_I_D_CODE_LENGTH_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinRFIDCodeLengthAttribute(
         IntegerAttributeCallback callback) {
-        readMinRFIDCodeLengthAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_R_F_I_D_CODE_LENGTH_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_R_F_I_D_CODE_LENGTH_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinRFIDCodeLengthAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinRFIDCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_R_F_I_D_CODE_LENGTH_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_R_F_I_D_CODE_LENGTH_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCredentialRulesSupportAttribute(
         IntegerAttributeCallback callback) {
-        readCredentialRulesSupportAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CREDENTIAL_RULES_SUPPORT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CREDENTIAL_RULES_SUPPORT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCredentialRulesSupportAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCredentialRulesSupportAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CREDENTIAL_RULES_SUPPORT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CREDENTIAL_RULES_SUPPORT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readNumberOfCredentialsSupportedPerUserAttribute(
         IntegerAttributeCallback callback) {
-        readNumberOfCredentialsSupportedPerUserAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_CREDENTIALS_SUPPORTED_PER_USER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NUMBER_OF_CREDENTIALS_SUPPORTED_PER_USER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeNumberOfCredentialsSupportedPerUserAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNumberOfCredentialsSupportedPerUserAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_CREDENTIALS_SUPPORTED_PER_USER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NUMBER_OF_CREDENTIALS_SUPPORTED_PER_USER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLanguageAttribute(
         CharStringAttributeCallback callback) {
-        readLanguageAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LANGUAGE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LANGUAGE_ATTRIBUTE_ID, true);
     }
 
     public void writeLanguageAttribute(DefaultClusterCallback callback, String value) {
-        writeLanguageAttribute(chipClusterPtr, callback, value, null);
+      writeLanguageAttribute(callback, value, 0);
     }
 
     public void writeLanguageAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) {
-        writeLanguageAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new StringType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LANGUAGE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeLanguageAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLanguageAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LANGUAGE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LANGUAGE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLEDSettingsAttribute(
         IntegerAttributeCallback callback) {
-        readLEDSettingsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, L_E_D_SETTINGS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, L_E_D_SETTINGS_ATTRIBUTE_ID, true);
     }
 
     public void writeLEDSettingsAttribute(DefaultClusterCallback callback, Integer value) {
-        writeLEDSettingsAttribute(chipClusterPtr, callback, value, null);
+      writeLEDSettingsAttribute(callback, value, 0);
     }
 
     public void writeLEDSettingsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeLEDSettingsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), L_E_D_SETTINGS_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeLEDSettingsAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLEDSettingsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, L_E_D_SETTINGS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, L_E_D_SETTINGS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAutoRelockTimeAttribute(
         LongAttributeCallback callback) {
-        readAutoRelockTimeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AUTO_RELOCK_TIME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AUTO_RELOCK_TIME_ATTRIBUTE_ID, true);
     }
 
     public void writeAutoRelockTimeAttribute(DefaultClusterCallback callback, Long value) {
-        writeAutoRelockTimeAttribute(chipClusterPtr, callback, value, null);
+      writeAutoRelockTimeAttribute(callback, value, 0);
     }
 
     public void writeAutoRelockTimeAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeAutoRelockTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), AUTO_RELOCK_TIME_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeAutoRelockTimeAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAutoRelockTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AUTO_RELOCK_TIME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AUTO_RELOCK_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSoundVolumeAttribute(
         IntegerAttributeCallback callback) {
-        readSoundVolumeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SOUND_VOLUME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SOUND_VOLUME_ATTRIBUTE_ID, true);
     }
 
     public void writeSoundVolumeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeSoundVolumeAttribute(chipClusterPtr, callback, value, null);
+      writeSoundVolumeAttribute(callback, value, 0);
     }
 
     public void writeSoundVolumeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeSoundVolumeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), SOUND_VOLUME_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeSoundVolumeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSoundVolumeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SOUND_VOLUME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SOUND_VOLUME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOperatingModeAttribute(
         IntegerAttributeCallback callback) {
-        readOperatingModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPERATING_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OPERATING_MODE_ATTRIBUTE_ID, true);
     }
 
     public void writeOperatingModeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOperatingModeAttribute(chipClusterPtr, callback, value, null);
+      writeOperatingModeAttribute(callback, value, 0);
     }
 
     public void writeOperatingModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOperatingModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), OPERATING_MODE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOperatingModeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOperatingModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPERATING_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OPERATING_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSupportedOperatingModesAttribute(
         IntegerAttributeCallback callback) {
-        readSupportedOperatingModesAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_OPERATING_MODES_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SUPPORTED_OPERATING_MODES_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSupportedOperatingModesAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSupportedOperatingModesAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_OPERATING_MODES_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SUPPORTED_OPERATING_MODES_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDefaultConfigurationRegisterAttribute(
         IntegerAttributeCallback callback) {
-        readDefaultConfigurationRegisterAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DEFAULT_CONFIGURATION_REGISTER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DEFAULT_CONFIGURATION_REGISTER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDefaultConfigurationRegisterAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDefaultConfigurationRegisterAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DEFAULT_CONFIGURATION_REGISTER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DEFAULT_CONFIGURATION_REGISTER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEnableLocalProgrammingAttribute(
         BooleanAttributeCallback callback) {
-        readEnableLocalProgrammingAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENABLE_LOCAL_PROGRAMMING_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ENABLE_LOCAL_PROGRAMMING_ATTRIBUTE_ID, true);
     }
 
     public void writeEnableLocalProgrammingAttribute(DefaultClusterCallback callback, Boolean value) {
-        writeEnableLocalProgrammingAttribute(chipClusterPtr, callback, value, null);
+      writeEnableLocalProgrammingAttribute(callback, value, 0);
     }
 
     public void writeEnableLocalProgrammingAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
-        writeEnableLocalProgrammingAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new BooleanType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ENABLE_LOCAL_PROGRAMMING_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeEnableLocalProgrammingAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEnableLocalProgrammingAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENABLE_LOCAL_PROGRAMMING_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ENABLE_LOCAL_PROGRAMMING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEnableOneTouchLockingAttribute(
         BooleanAttributeCallback callback) {
-        readEnableOneTouchLockingAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENABLE_ONE_TOUCH_LOCKING_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ENABLE_ONE_TOUCH_LOCKING_ATTRIBUTE_ID, true);
     }
 
     public void writeEnableOneTouchLockingAttribute(DefaultClusterCallback callback, Boolean value) {
-        writeEnableOneTouchLockingAttribute(chipClusterPtr, callback, value, null);
+      writeEnableOneTouchLockingAttribute(callback, value, 0);
     }
 
     public void writeEnableOneTouchLockingAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
-        writeEnableOneTouchLockingAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new BooleanType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ENABLE_ONE_TOUCH_LOCKING_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeEnableOneTouchLockingAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEnableOneTouchLockingAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENABLE_ONE_TOUCH_LOCKING_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ENABLE_ONE_TOUCH_LOCKING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEnableInsideStatusLEDAttribute(
         BooleanAttributeCallback callback) {
-        readEnableInsideStatusLEDAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENABLE_INSIDE_STATUS_L_E_D_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ENABLE_INSIDE_STATUS_L_E_D_ATTRIBUTE_ID, true);
     }
 
     public void writeEnableInsideStatusLEDAttribute(DefaultClusterCallback callback, Boolean value) {
-        writeEnableInsideStatusLEDAttribute(chipClusterPtr, callback, value, null);
+      writeEnableInsideStatusLEDAttribute(callback, value, 0);
     }
 
     public void writeEnableInsideStatusLEDAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
-        writeEnableInsideStatusLEDAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new BooleanType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ENABLE_INSIDE_STATUS_L_E_D_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeEnableInsideStatusLEDAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEnableInsideStatusLEDAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENABLE_INSIDE_STATUS_L_E_D_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ENABLE_INSIDE_STATUS_L_E_D_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEnablePrivacyModeButtonAttribute(
         BooleanAttributeCallback callback) {
-        readEnablePrivacyModeButtonAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENABLE_PRIVACY_MODE_BUTTON_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ENABLE_PRIVACY_MODE_BUTTON_ATTRIBUTE_ID, true);
     }
 
     public void writeEnablePrivacyModeButtonAttribute(DefaultClusterCallback callback, Boolean value) {
-        writeEnablePrivacyModeButtonAttribute(chipClusterPtr, callback, value, null);
+      writeEnablePrivacyModeButtonAttribute(callback, value, 0);
     }
 
     public void writeEnablePrivacyModeButtonAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
-        writeEnablePrivacyModeButtonAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new BooleanType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ENABLE_PRIVACY_MODE_BUTTON_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeEnablePrivacyModeButtonAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEnablePrivacyModeButtonAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENABLE_PRIVACY_MODE_BUTTON_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ENABLE_PRIVACY_MODE_BUTTON_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLocalProgrammingFeaturesAttribute(
         IntegerAttributeCallback callback) {
-        readLocalProgrammingFeaturesAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOCAL_PROGRAMMING_FEATURES_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LOCAL_PROGRAMMING_FEATURES_ATTRIBUTE_ID, true);
     }
 
     public void writeLocalProgrammingFeaturesAttribute(DefaultClusterCallback callback, Integer value) {
-        writeLocalProgrammingFeaturesAttribute(chipClusterPtr, callback, value, null);
+      writeLocalProgrammingFeaturesAttribute(callback, value, 0);
     }
 
     public void writeLocalProgrammingFeaturesAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeLocalProgrammingFeaturesAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LOCAL_PROGRAMMING_FEATURES_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeLocalProgrammingFeaturesAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLocalProgrammingFeaturesAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOCAL_PROGRAMMING_FEATURES_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LOCAL_PROGRAMMING_FEATURES_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readWrongCodeEntryLimitAttribute(
         IntegerAttributeCallback callback) {
-        readWrongCodeEntryLimitAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WRONG_CODE_ENTRY_LIMIT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, WRONG_CODE_ENTRY_LIMIT_ATTRIBUTE_ID, true);
     }
 
     public void writeWrongCodeEntryLimitAttribute(DefaultClusterCallback callback, Integer value) {
-        writeWrongCodeEntryLimitAttribute(chipClusterPtr, callback, value, null);
+      writeWrongCodeEntryLimitAttribute(callback, value, 0);
     }
 
     public void writeWrongCodeEntryLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeWrongCodeEntryLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), WRONG_CODE_ENTRY_LIMIT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeWrongCodeEntryLimitAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeWrongCodeEntryLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WRONG_CODE_ENTRY_LIMIT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, WRONG_CODE_ENTRY_LIMIT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUserCodeTemporaryDisableTimeAttribute(
         IntegerAttributeCallback callback) {
-        readUserCodeTemporaryDisableTimeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, USER_CODE_TEMPORARY_DISABLE_TIME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, USER_CODE_TEMPORARY_DISABLE_TIME_ATTRIBUTE_ID, true);
     }
 
     public void writeUserCodeTemporaryDisableTimeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeUserCodeTemporaryDisableTimeAttribute(chipClusterPtr, callback, value, null);
+      writeUserCodeTemporaryDisableTimeAttribute(callback, value, 0);
     }
 
     public void writeUserCodeTemporaryDisableTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeUserCodeTemporaryDisableTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), USER_CODE_TEMPORARY_DISABLE_TIME_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeUserCodeTemporaryDisableTimeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUserCodeTemporaryDisableTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, USER_CODE_TEMPORARY_DISABLE_TIME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, USER_CODE_TEMPORARY_DISABLE_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSendPINOverTheAirAttribute(
         BooleanAttributeCallback callback) {
-        readSendPINOverTheAirAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SEND_P_I_N_OVER_THE_AIR_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SEND_P_I_N_OVER_THE_AIR_ATTRIBUTE_ID, true);
     }
 
     public void writeSendPINOverTheAirAttribute(DefaultClusterCallback callback, Boolean value) {
-        writeSendPINOverTheAirAttribute(chipClusterPtr, callback, value, null);
+      writeSendPINOverTheAirAttribute(callback, value, 0);
     }
 
     public void writeSendPINOverTheAirAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
-        writeSendPINOverTheAirAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new BooleanType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), SEND_P_I_N_OVER_THE_AIR_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeSendPINOverTheAirAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSendPINOverTheAirAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SEND_P_I_N_OVER_THE_AIR_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SEND_P_I_N_OVER_THE_AIR_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRequirePINforRemoteOperationAttribute(
         BooleanAttributeCallback callback) {
-        readRequirePINforRemoteOperationAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REQUIRE_P_I_NFOR_REMOTE_OPERATION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, REQUIRE_P_I_NFOR_REMOTE_OPERATION_ATTRIBUTE_ID, true);
     }
 
     public void writeRequirePINforRemoteOperationAttribute(DefaultClusterCallback callback, Boolean value) {
-        writeRequirePINforRemoteOperationAttribute(chipClusterPtr, callback, value, null);
+      writeRequirePINforRemoteOperationAttribute(callback, value, 0);
     }
 
     public void writeRequirePINforRemoteOperationAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
-        writeRequirePINforRemoteOperationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new BooleanType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), REQUIRE_P_I_NFOR_REMOTE_OPERATION_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeRequirePINforRemoteOperationAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRequirePINforRemoteOperationAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REQUIRE_P_I_NFOR_REMOTE_OPERATION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, REQUIRE_P_I_NFOR_REMOTE_OPERATION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readExpiringUserTimeoutAttribute(
         IntegerAttributeCallback callback) {
-        readExpiringUserTimeoutAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EXPIRING_USER_TIMEOUT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EXPIRING_USER_TIMEOUT_ATTRIBUTE_ID, true);
     }
 
     public void writeExpiringUserTimeoutAttribute(DefaultClusterCallback callback, Integer value) {
-        writeExpiringUserTimeoutAttribute(chipClusterPtr, callback, value, null);
+      writeExpiringUserTimeoutAttribute(callback, value, 0);
     }
 
     public void writeExpiringUserTimeoutAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeExpiringUserTimeoutAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), EXPIRING_USER_TIMEOUT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeExpiringUserTimeoutAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeExpiringUserTimeoutAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EXPIRING_USER_TIMEOUT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EXPIRING_USER_TIMEOUT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
+  }
 
-    private native void readLockStateAttribute(long chipClusterPtr, LockStateAttributeCallback callback);
+  public static class WindowCoveringCluster extends BaseChipCluster {
+    public static final long CLUSTER_ID = 258L;
 
-    private native void subscribeLockStateAttribute(long chipClusterPtr, LockStateAttributeCallback callback, int minInterval, int maxInterval);
+    private static final long TYPE_ATTRIBUTE_ID = 0L;
+    private static final long PHYSICAL_CLOSED_LIMIT_LIFT_ATTRIBUTE_ID = 1L;
+    private static final long PHYSICAL_CLOSED_LIMIT_TILT_ATTRIBUTE_ID = 2L;
+    private static final long CURRENT_POSITION_LIFT_ATTRIBUTE_ID = 3L;
+    private static final long CURRENT_POSITION_TILT_ATTRIBUTE_ID = 4L;
+    private static final long NUMBER_OF_ACTUATIONS_LIFT_ATTRIBUTE_ID = 5L;
+    private static final long NUMBER_OF_ACTUATIONS_TILT_ATTRIBUTE_ID = 6L;
+    private static final long CONFIG_STATUS_ATTRIBUTE_ID = 7L;
+    private static final long CURRENT_POSITION_LIFT_PERCENTAGE_ATTRIBUTE_ID = 8L;
+    private static final long CURRENT_POSITION_TILT_PERCENTAGE_ATTRIBUTE_ID = 9L;
+    private static final long OPERATIONAL_STATUS_ATTRIBUTE_ID = 10L;
+    private static final long TARGET_POSITION_LIFT_PERCENT100THS_ATTRIBUTE_ID = 11L;
+    private static final long TARGET_POSITION_TILT_PERCENT100THS_ATTRIBUTE_ID = 12L;
+    private static final long END_PRODUCT_TYPE_ATTRIBUTE_ID = 13L;
+    private static final long CURRENT_POSITION_LIFT_PERCENT100THS_ATTRIBUTE_ID = 14L;
+    private static final long CURRENT_POSITION_TILT_PERCENT100THS_ATTRIBUTE_ID = 15L;
+    private static final long INSTALLED_OPEN_LIMIT_LIFT_ATTRIBUTE_ID = 16L;
+    private static final long INSTALLED_CLOSED_LIMIT_LIFT_ATTRIBUTE_ID = 17L;
+    private static final long INSTALLED_OPEN_LIMIT_TILT_ATTRIBUTE_ID = 18L;
+    private static final long INSTALLED_CLOSED_LIMIT_TILT_ATTRIBUTE_ID = 19L;
+    private static final long MODE_ATTRIBUTE_ID = 23L;
+    private static final long SAFETY_STATUS_ATTRIBUTE_ID = 26L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
 
-    private native void readLockTypeAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public WindowCoveringCluster(long devicePtr, int endpointId) {
+      super(devicePtr, endpointId, CLUSTER_ID);
+    }
 
-    private native void subscribeLockTypeAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    @Override
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    private native void readActuatorEnabledAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
+    public void upOrOpen(DefaultClusterCallback callback) {
+      upOrOpen(callback, 0);
+    }
 
-    private native void subscribeActuatorEnabledAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
+    public void upOrOpen(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
+      final long commandId = 0L;
 
-    private native void readDoorStateAttribute(long chipClusterPtr, DoorStateAttributeCallback callback);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void subscribeDoorStateAttribute(long chipClusterPtr, DoorStateAttributeCallback callback, int minInterval, int maxInterval);
+    public void downOrClose(DefaultClusterCallback callback) {
+      downOrClose(callback, 0);
+    }
 
-    private native void readDoorOpenEventsAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void downOrClose(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
+      final long commandId = 1L;
 
-    private native void writeDoorOpenEventsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void subscribeDoorOpenEventsAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+    public void stopMotion(DefaultClusterCallback callback) {
+      stopMotion(callback, 0);
+    }
 
-    private native void readDoorClosedEventsAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void stopMotion(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
+      final long commandId = 2L;
 
-    private native void writeDoorClosedEventsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void subscribeDoorClosedEventsAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+    public void goToLiftValue(DefaultClusterCallback callback, Integer liftValue) {
+      goToLiftValue(callback, liftValue, 0);
+    }
 
-    private native void readOpenPeriodAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void goToLiftValue(DefaultClusterCallback callback, Integer liftValue, int timedInvokeTimeoutMs) {
+      final long commandId = 4L;
 
-    private native void writeOpenPeriodAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long liftValueFieldID = 0L;
+      BaseTLVType liftValuetlvValue = new UIntType(liftValue);
+      elements.add(new StructElement(liftValueFieldID, liftValuetlvValue));
 
-    private native void subscribeOpenPeriodAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void readNumberOfTotalUsersSupportedAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void goToLiftPercentage(DefaultClusterCallback callback, Integer liftPercent100thsValue) {
+      goToLiftPercentage(callback, liftPercent100thsValue, 0);
+    }
 
-    private native void subscribeNumberOfTotalUsersSupportedAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void goToLiftPercentage(DefaultClusterCallback callback, Integer liftPercent100thsValue, int timedInvokeTimeoutMs) {
+      final long commandId = 5L;
 
-    private native void readNumberOfPINUsersSupportedAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long liftPercent100thsValueFieldID = 0L;
+      BaseTLVType liftPercent100thsValuetlvValue = new UIntType(liftPercent100thsValue);
+      elements.add(new StructElement(liftPercent100thsValueFieldID, liftPercent100thsValuetlvValue));
 
-    private native void subscribeNumberOfPINUsersSupportedAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void readNumberOfRFIDUsersSupportedAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void goToTiltValue(DefaultClusterCallback callback, Integer tiltValue) {
+      goToTiltValue(callback, tiltValue, 0);
+    }
 
-    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 readNumberOfHolidaySchedulesSupportedAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeNumberOfHolidaySchedulesSupportedAttribute(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 readCredentialRulesSupportAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeCredentialRulesSupportAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readNumberOfCredentialsSupportedPerUserAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeNumberOfCredentialsSupportedPerUserAttribute(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 readLEDSettingsAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeLEDSettingsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeLEDSettingsAttribute(long chipClusterPtr, IntegerAttributeCallback 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 readDefaultConfigurationRegisterAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeDefaultConfigurationRegisterAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEnableLocalProgrammingAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
-
-    private native void writeEnableLocalProgrammingAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeEnableLocalProgrammingAttribute(long chipClusterPtr, BooleanAttributeCallback 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 readEnableInsideStatusLEDAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
-
-    private native void writeEnableInsideStatusLEDAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeEnableInsideStatusLEDAttribute(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 readLocalProgrammingFeaturesAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeLocalProgrammingFeaturesAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeLocalProgrammingFeaturesAttribute(long chipClusterPtr, IntegerAttributeCallback 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 readUserCodeTemporaryDisableTimeAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeUserCodeTemporaryDisableTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeUserCodeTemporaryDisableTimeAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSendPINOverTheAirAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
-
-    private native void writeSendPINOverTheAirAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeSendPINOverTheAirAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRequirePINforRemoteOperationAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
-
-    private native void writeRequirePINforRemoteOperationAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeRequirePINforRemoteOperationAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readExpiringUserTimeoutAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeExpiringUserTimeoutAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeExpiringUserTimeoutAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-  }
-
-  public static class WindowCoveringCluster extends BaseChipCluster {
-    public static final long CLUSTER_ID = 258L;
-
-    public WindowCoveringCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
-    }
-
-    @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
-
-    public void upOrOpen(DefaultClusterCallback callback) {
-      upOrOpen(chipClusterPtr, callback, null);
-    }
-
-    public void upOrOpen(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      upOrOpen(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
-
-    public void downOrClose(DefaultClusterCallback callback) {
-      downOrClose(chipClusterPtr, callback, null);
-    }
-
-    public void downOrClose(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      downOrClose(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
-
-    public void stopMotion(DefaultClusterCallback callback) {
-      stopMotion(chipClusterPtr, callback, null);
-    }
-
-    public void stopMotion(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      stopMotion(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
-
-    public void goToLiftValue(DefaultClusterCallback callback, Integer liftValue) {
-      goToLiftValue(chipClusterPtr, callback, liftValue, null);
-    }
-
-    public void goToLiftValue(DefaultClusterCallback callback, Integer liftValue, int timedInvokeTimeoutMs) {
-      goToLiftValue(chipClusterPtr, callback, liftValue, timedInvokeTimeoutMs);
-    }
-
-    public void goToLiftPercentage(DefaultClusterCallback callback, Integer liftPercent100thsValue) {
-      goToLiftPercentage(chipClusterPtr, callback, liftPercent100thsValue, null);
-    }
-
-    public void goToLiftPercentage(DefaultClusterCallback callback, Integer liftPercent100thsValue, int timedInvokeTimeoutMs) {
-      goToLiftPercentage(chipClusterPtr, callback, liftPercent100thsValue, timedInvokeTimeoutMs);
-    }
+    public void goToTiltValue(DefaultClusterCallback callback, Integer tiltValue, int timedInvokeTimeoutMs) {
+      final long commandId = 7L;
 
-    public void goToTiltValue(DefaultClusterCallback callback, Integer tiltValue) {
-      goToTiltValue(chipClusterPtr, callback, tiltValue, null);
-    }
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long tiltValueFieldID = 0L;
+      BaseTLVType tiltValuetlvValue = new UIntType(tiltValue);
+      elements.add(new StructElement(tiltValueFieldID, tiltValuetlvValue));
 
-    public void goToTiltValue(DefaultClusterCallback callback, Integer tiltValue, int timedInvokeTimeoutMs) {
-      goToTiltValue(chipClusterPtr, callback, tiltValue, timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void goToTiltPercentage(DefaultClusterCallback callback, Integer tiltPercent100thsValue) {
-      goToTiltPercentage(chipClusterPtr, callback, tiltPercent100thsValue, null);
+      goToTiltPercentage(callback, tiltPercent100thsValue, 0);
     }
 
     public void goToTiltPercentage(DefaultClusterCallback callback, Integer tiltPercent100thsValue, int timedInvokeTimeoutMs) {
-      goToTiltPercentage(chipClusterPtr, callback, tiltPercent100thsValue, timedInvokeTimeoutMs);
-    }
-
-    private native void upOrOpen(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void downOrClose(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void stopMotion(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void goToLiftValue(long chipClusterPtr, DefaultClusterCallback callback, Integer liftValue, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void goToLiftPercentage(long chipClusterPtr, DefaultClusterCallback callback, Integer liftPercent100thsValue, @Nullable Integer timedInvokeTimeoutMs);
+      final long commandId = 8L;
 
-    private native void goToTiltValue(long chipClusterPtr, DefaultClusterCallback callback, Integer tiltValue, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long tiltPercent100thsValueFieldID = 0L;
+      BaseTLVType tiltPercent100thsValuetlvValue = new UIntType(tiltPercent100thsValue);
+      elements.add(new StructElement(tiltPercent100thsValueFieldID, tiltPercent100thsValuetlvValue));
 
-    private native void goToTiltPercentage(long chipClusterPtr, DefaultClusterCallback callback, Integer tiltPercent100thsValue, @Nullable Integer timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface CurrentPositionLiftAttributeCallback {
+    public interface CurrentPositionLiftAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface CurrentPositionTiltAttributeCallback {
+    public interface CurrentPositionTiltAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface CurrentPositionLiftPercentageAttributeCallback {
+    public interface CurrentPositionLiftPercentageAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface CurrentPositionTiltPercentageAttributeCallback {
+    public interface CurrentPositionTiltPercentageAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface TargetPositionLiftPercent100thsAttributeCallback {
+    public interface TargetPositionLiftPercent100thsAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface TargetPositionTiltPercent100thsAttributeCallback {
+    public interface TargetPositionTiltPercent100thsAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface CurrentPositionLiftPercent100thsAttributeCallback {
+    public interface CurrentPositionLiftPercent100thsAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface CurrentPositionTiltPercent100thsAttributeCallback {
+    public interface CurrentPositionTiltPercent100thsAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readTypeAttribute(
         IntegerAttributeCallback callback) {
-        readTypeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TYPE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TYPE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTypeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TYPE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TYPE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPhysicalClosedLimitLiftAttribute(
         IntegerAttributeCallback callback) {
-        readPhysicalClosedLimitLiftAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PHYSICAL_CLOSED_LIMIT_LIFT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PHYSICAL_CLOSED_LIMIT_LIFT_ATTRIBUTE_ID, true);
     }
 
     public void subscribePhysicalClosedLimitLiftAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePhysicalClosedLimitLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PHYSICAL_CLOSED_LIMIT_LIFT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PHYSICAL_CLOSED_LIMIT_LIFT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPhysicalClosedLimitTiltAttribute(
         IntegerAttributeCallback callback) {
-        readPhysicalClosedLimitTiltAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PHYSICAL_CLOSED_LIMIT_TILT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PHYSICAL_CLOSED_LIMIT_TILT_ATTRIBUTE_ID, true);
     }
 
     public void subscribePhysicalClosedLimitTiltAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePhysicalClosedLimitTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PHYSICAL_CLOSED_LIMIT_TILT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PHYSICAL_CLOSED_LIMIT_TILT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentPositionLiftAttribute(
         CurrentPositionLiftAttributeCallback callback) {
-        readCurrentPositionLiftAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_POSITION_LIFT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_POSITION_LIFT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentPositionLiftAttribute(
         CurrentPositionLiftAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentPositionLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_POSITION_LIFT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_POSITION_LIFT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentPositionTiltAttribute(
         CurrentPositionTiltAttributeCallback callback) {
-        readCurrentPositionTiltAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_POSITION_TILT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_POSITION_TILT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentPositionTiltAttribute(
         CurrentPositionTiltAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentPositionTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_POSITION_TILT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_POSITION_TILT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readNumberOfActuationsLiftAttribute(
         IntegerAttributeCallback callback) {
-        readNumberOfActuationsLiftAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_ACTUATIONS_LIFT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NUMBER_OF_ACTUATIONS_LIFT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeNumberOfActuationsLiftAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNumberOfActuationsLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_ACTUATIONS_LIFT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NUMBER_OF_ACTUATIONS_LIFT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readNumberOfActuationsTiltAttribute(
         IntegerAttributeCallback callback) {
-        readNumberOfActuationsTiltAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_ACTUATIONS_TILT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NUMBER_OF_ACTUATIONS_TILT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeNumberOfActuationsTiltAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNumberOfActuationsTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_ACTUATIONS_TILT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NUMBER_OF_ACTUATIONS_TILT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readConfigStatusAttribute(
         IntegerAttributeCallback callback) {
-        readConfigStatusAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CONFIG_STATUS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CONFIG_STATUS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeConfigStatusAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeConfigStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CONFIG_STATUS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CONFIG_STATUS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentPositionLiftPercentageAttribute(
         CurrentPositionLiftPercentageAttributeCallback callback) {
-        readCurrentPositionLiftPercentageAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_POSITION_LIFT_PERCENTAGE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_POSITION_LIFT_PERCENTAGE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentPositionLiftPercentageAttribute(
         CurrentPositionLiftPercentageAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentPositionLiftPercentageAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_POSITION_LIFT_PERCENTAGE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_POSITION_LIFT_PERCENTAGE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentPositionTiltPercentageAttribute(
         CurrentPositionTiltPercentageAttributeCallback callback) {
-        readCurrentPositionTiltPercentageAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_POSITION_TILT_PERCENTAGE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_POSITION_TILT_PERCENTAGE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentPositionTiltPercentageAttribute(
         CurrentPositionTiltPercentageAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentPositionTiltPercentageAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_POSITION_TILT_PERCENTAGE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_POSITION_TILT_PERCENTAGE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOperationalStatusAttribute(
         IntegerAttributeCallback callback) {
-        readOperationalStatusAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPERATIONAL_STATUS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OPERATIONAL_STATUS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeOperationalStatusAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOperationalStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPERATIONAL_STATUS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OPERATIONAL_STATUS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTargetPositionLiftPercent100thsAttribute(
         TargetPositionLiftPercent100thsAttributeCallback callback) {
-        readTargetPositionLiftPercent100thsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TARGET_POSITION_LIFT_PERCENT100THS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TARGET_POSITION_LIFT_PERCENT100THS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTargetPositionLiftPercent100thsAttribute(
         TargetPositionLiftPercent100thsAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTargetPositionLiftPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TARGET_POSITION_LIFT_PERCENT100THS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TARGET_POSITION_LIFT_PERCENT100THS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTargetPositionTiltPercent100thsAttribute(
         TargetPositionTiltPercent100thsAttributeCallback callback) {
-        readTargetPositionTiltPercent100thsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TARGET_POSITION_TILT_PERCENT100THS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TARGET_POSITION_TILT_PERCENT100THS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTargetPositionTiltPercent100thsAttribute(
         TargetPositionTiltPercent100thsAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTargetPositionTiltPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TARGET_POSITION_TILT_PERCENT100THS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TARGET_POSITION_TILT_PERCENT100THS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEndProductTypeAttribute(
         IntegerAttributeCallback callback) {
-        readEndProductTypeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, END_PRODUCT_TYPE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, END_PRODUCT_TYPE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEndProductTypeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEndProductTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, END_PRODUCT_TYPE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, END_PRODUCT_TYPE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentPositionLiftPercent100thsAttribute(
         CurrentPositionLiftPercent100thsAttributeCallback callback) {
-        readCurrentPositionLiftPercent100thsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_POSITION_LIFT_PERCENT100THS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_POSITION_LIFT_PERCENT100THS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentPositionLiftPercent100thsAttribute(
         CurrentPositionLiftPercent100thsAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentPositionLiftPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_POSITION_LIFT_PERCENT100THS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_POSITION_LIFT_PERCENT100THS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentPositionTiltPercent100thsAttribute(
         CurrentPositionTiltPercent100thsAttributeCallback callback) {
-        readCurrentPositionTiltPercent100thsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_POSITION_TILT_PERCENT100THS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_POSITION_TILT_PERCENT100THS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentPositionTiltPercent100thsAttribute(
         CurrentPositionTiltPercent100thsAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentPositionTiltPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_POSITION_TILT_PERCENT100THS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_POSITION_TILT_PERCENT100THS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readInstalledOpenLimitLiftAttribute(
         IntegerAttributeCallback callback) {
-        readInstalledOpenLimitLiftAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INSTALLED_OPEN_LIMIT_LIFT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INSTALLED_OPEN_LIMIT_LIFT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeInstalledOpenLimitLiftAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInstalledOpenLimitLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INSTALLED_OPEN_LIMIT_LIFT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INSTALLED_OPEN_LIMIT_LIFT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readInstalledClosedLimitLiftAttribute(
         IntegerAttributeCallback callback) {
-        readInstalledClosedLimitLiftAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INSTALLED_CLOSED_LIMIT_LIFT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INSTALLED_CLOSED_LIMIT_LIFT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeInstalledClosedLimitLiftAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInstalledClosedLimitLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INSTALLED_CLOSED_LIMIT_LIFT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INSTALLED_CLOSED_LIMIT_LIFT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readInstalledOpenLimitTiltAttribute(
         IntegerAttributeCallback callback) {
-        readInstalledOpenLimitTiltAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INSTALLED_OPEN_LIMIT_TILT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INSTALLED_OPEN_LIMIT_TILT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeInstalledOpenLimitTiltAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInstalledOpenLimitTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INSTALLED_OPEN_LIMIT_TILT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INSTALLED_OPEN_LIMIT_TILT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readInstalledClosedLimitTiltAttribute(
         IntegerAttributeCallback callback) {
-        readInstalledClosedLimitTiltAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INSTALLED_CLOSED_LIMIT_TILT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INSTALLED_CLOSED_LIMIT_TILT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeInstalledClosedLimitTiltAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInstalledClosedLimitTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INSTALLED_CLOSED_LIMIT_TILT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INSTALLED_CLOSED_LIMIT_TILT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readModeAttribute(
         IntegerAttributeCallback callback) {
-        readModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MODE_ATTRIBUTE_ID, true);
     }
 
     public void writeModeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeModeAttribute(chipClusterPtr, callback, value, null);
+      writeModeAttribute(callback, value, 0);
     }
 
     public void writeModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), MODE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeModeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSafetyStatusAttribute(
         IntegerAttributeCallback callback) {
-        readSafetyStatusAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SAFETY_STATUS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SAFETY_STATUS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSafetyStatusAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSafetyStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SAFETY_STATUS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SAFETY_STATUS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readPhysicalClosedLimitLiftAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribePhysicalClosedLimitLiftAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPhysicalClosedLimitTiltAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribePhysicalClosedLimitTiltAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readCurrentPositionLiftAttribute(long chipClusterPtr, CurrentPositionLiftAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    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 readNumberOfActuationsLiftAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeNumberOfActuationsLiftAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readNumberOfActuationsTiltAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeNumberOfActuationsTiltAttribute(long chipClusterPtr, IntegerAttributeCallback 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 readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class BarrierControlCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 259L;
 
+    private static final long BARRIER_MOVING_STATE_ATTRIBUTE_ID = 1L;
+    private static final long BARRIER_SAFETY_STATUS_ATTRIBUTE_ID = 2L;
+    private static final long BARRIER_CAPABILITIES_ATTRIBUTE_ID = 3L;
+    private static final long BARRIER_OPEN_EVENTS_ATTRIBUTE_ID = 4L;
+    private static final long BARRIER_CLOSE_EVENTS_ATTRIBUTE_ID = 5L;
+    private static final long BARRIER_COMMAND_OPEN_EVENTS_ATTRIBUTE_ID = 6L;
+    private static final long BARRIER_COMMAND_CLOSE_EVENTS_ATTRIBUTE_ID = 7L;
+    private static final long BARRIER_OPEN_PERIOD_ATTRIBUTE_ID = 8L;
+    private static final long BARRIER_CLOSE_PERIOD_ATTRIBUTE_ID = 9L;
+    private static final long BARRIER_POSITION_ATTRIBUTE_ID = 10L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public BarrierControlCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void barrierControlGoToPercent(DefaultClusterCallback callback, Integer percentOpen) {
-      barrierControlGoToPercent(chipClusterPtr, callback, percentOpen, null);
+      barrierControlGoToPercent(callback, percentOpen, 0);
     }
 
     public void barrierControlGoToPercent(DefaultClusterCallback callback, Integer percentOpen, int timedInvokeTimeoutMs) {
-      barrierControlGoToPercent(chipClusterPtr, callback, percentOpen, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long percentOpenFieldID = 0L;
+      BaseTLVType percentOpentlvValue = new UIntType(percentOpen);
+      elements.add(new StructElement(percentOpenFieldID, percentOpentlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void barrierControlStop(DefaultClusterCallback callback) {
-      barrierControlStop(chipClusterPtr, callback, null);
+      barrierControlStop(callback, 0);
     }
 
     public void barrierControlStop(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      barrierControlStop(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
-
-    private native void barrierControlGoToPercent(long chipClusterPtr, DefaultClusterCallback callback, Integer percentOpen, @Nullable Integer timedInvokeTimeoutMs);
+      final long commandId = 1L;
 
-    private native void barrierControlStop(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readBarrierMovingStateAttribute(
         IntegerAttributeCallback callback) {
-        readBarrierMovingStateAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BARRIER_MOVING_STATE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BARRIER_MOVING_STATE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBarrierMovingStateAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBarrierMovingStateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BARRIER_MOVING_STATE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BARRIER_MOVING_STATE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBarrierSafetyStatusAttribute(
         IntegerAttributeCallback callback) {
-        readBarrierSafetyStatusAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BARRIER_SAFETY_STATUS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BARRIER_SAFETY_STATUS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBarrierSafetyStatusAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBarrierSafetyStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BARRIER_SAFETY_STATUS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BARRIER_SAFETY_STATUS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBarrierCapabilitiesAttribute(
         IntegerAttributeCallback callback) {
-        readBarrierCapabilitiesAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BARRIER_CAPABILITIES_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BARRIER_CAPABILITIES_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBarrierCapabilitiesAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBarrierCapabilitiesAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BARRIER_CAPABILITIES_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BARRIER_CAPABILITIES_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBarrierOpenEventsAttribute(
         IntegerAttributeCallback callback) {
-        readBarrierOpenEventsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BARRIER_OPEN_EVENTS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BARRIER_OPEN_EVENTS_ATTRIBUTE_ID, true);
     }
 
     public void writeBarrierOpenEventsAttribute(DefaultClusterCallback callback, Integer value) {
-        writeBarrierOpenEventsAttribute(chipClusterPtr, callback, value, null);
+      writeBarrierOpenEventsAttribute(callback, value, 0);
     }
 
     public void writeBarrierOpenEventsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeBarrierOpenEventsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), BARRIER_OPEN_EVENTS_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeBarrierOpenEventsAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBarrierOpenEventsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BARRIER_OPEN_EVENTS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BARRIER_OPEN_EVENTS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBarrierCloseEventsAttribute(
         IntegerAttributeCallback callback) {
-        readBarrierCloseEventsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BARRIER_CLOSE_EVENTS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BARRIER_CLOSE_EVENTS_ATTRIBUTE_ID, true);
     }
 
     public void writeBarrierCloseEventsAttribute(DefaultClusterCallback callback, Integer value) {
-        writeBarrierCloseEventsAttribute(chipClusterPtr, callback, value, null);
+      writeBarrierCloseEventsAttribute(callback, value, 0);
     }
 
     public void writeBarrierCloseEventsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeBarrierCloseEventsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), BARRIER_CLOSE_EVENTS_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeBarrierCloseEventsAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBarrierCloseEventsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BARRIER_CLOSE_EVENTS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BARRIER_CLOSE_EVENTS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBarrierCommandOpenEventsAttribute(
         IntegerAttributeCallback callback) {
-        readBarrierCommandOpenEventsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BARRIER_COMMAND_OPEN_EVENTS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BARRIER_COMMAND_OPEN_EVENTS_ATTRIBUTE_ID, true);
     }
 
     public void writeBarrierCommandOpenEventsAttribute(DefaultClusterCallback callback, Integer value) {
-        writeBarrierCommandOpenEventsAttribute(chipClusterPtr, callback, value, null);
+      writeBarrierCommandOpenEventsAttribute(callback, value, 0);
     }
 
     public void writeBarrierCommandOpenEventsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeBarrierCommandOpenEventsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), BARRIER_COMMAND_OPEN_EVENTS_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeBarrierCommandOpenEventsAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBarrierCommandOpenEventsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BARRIER_COMMAND_OPEN_EVENTS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BARRIER_COMMAND_OPEN_EVENTS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBarrierCommandCloseEventsAttribute(
         IntegerAttributeCallback callback) {
-        readBarrierCommandCloseEventsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BARRIER_COMMAND_CLOSE_EVENTS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BARRIER_COMMAND_CLOSE_EVENTS_ATTRIBUTE_ID, true);
     }
 
     public void writeBarrierCommandCloseEventsAttribute(DefaultClusterCallback callback, Integer value) {
-        writeBarrierCommandCloseEventsAttribute(chipClusterPtr, callback, value, null);
+      writeBarrierCommandCloseEventsAttribute(callback, value, 0);
     }
 
     public void writeBarrierCommandCloseEventsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeBarrierCommandCloseEventsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), BARRIER_COMMAND_CLOSE_EVENTS_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeBarrierCommandCloseEventsAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBarrierCommandCloseEventsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BARRIER_COMMAND_CLOSE_EVENTS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BARRIER_COMMAND_CLOSE_EVENTS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBarrierOpenPeriodAttribute(
         IntegerAttributeCallback callback) {
-        readBarrierOpenPeriodAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BARRIER_OPEN_PERIOD_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BARRIER_OPEN_PERIOD_ATTRIBUTE_ID, true);
     }
 
     public void writeBarrierOpenPeriodAttribute(DefaultClusterCallback callback, Integer value) {
-        writeBarrierOpenPeriodAttribute(chipClusterPtr, callback, value, null);
+      writeBarrierOpenPeriodAttribute(callback, value, 0);
     }
 
     public void writeBarrierOpenPeriodAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeBarrierOpenPeriodAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), BARRIER_OPEN_PERIOD_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeBarrierOpenPeriodAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBarrierOpenPeriodAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BARRIER_OPEN_PERIOD_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BARRIER_OPEN_PERIOD_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBarrierClosePeriodAttribute(
         IntegerAttributeCallback callback) {
-        readBarrierClosePeriodAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BARRIER_CLOSE_PERIOD_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BARRIER_CLOSE_PERIOD_ATTRIBUTE_ID, true);
     }
 
     public void writeBarrierClosePeriodAttribute(DefaultClusterCallback callback, Integer value) {
-        writeBarrierClosePeriodAttribute(chipClusterPtr, callback, value, null);
+      writeBarrierClosePeriodAttribute(callback, value, 0);
     }
 
     public void writeBarrierClosePeriodAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeBarrierClosePeriodAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), BARRIER_CLOSE_PERIOD_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeBarrierClosePeriodAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBarrierClosePeriodAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BARRIER_CLOSE_PERIOD_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BARRIER_CLOSE_PERIOD_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBarrierPositionAttribute(
         IntegerAttributeCallback callback) {
-        readBarrierPositionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BARRIER_POSITION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BARRIER_POSITION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBarrierPositionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBarrierPositionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BARRIER_POSITION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BARRIER_POSITION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readBarrierOpenEventsAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void writeBarrierOpenEventsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeBarrierOpenEventsAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBarrierCloseEventsAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeBarrierCloseEventsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeBarrierCloseEventsAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBarrierCommandOpenEventsAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeBarrierCommandOpenEventsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeBarrierCommandOpenEventsAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBarrierCommandCloseEventsAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeBarrierCommandCloseEventsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeBarrierCommandCloseEventsAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBarrierOpenPeriodAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeBarrierOpenPeriodAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeBarrierOpenPeriodAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBarrierClosePeriodAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeBarrierClosePeriodAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeBarrierClosePeriodAttribute(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 readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class PumpConfigurationAndControlCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 512L;
 
+    private static final long MAX_PRESSURE_ATTRIBUTE_ID = 0L;
+    private static final long MAX_SPEED_ATTRIBUTE_ID = 1L;
+    private static final long MAX_FLOW_ATTRIBUTE_ID = 2L;
+    private static final long MIN_CONST_PRESSURE_ATTRIBUTE_ID = 3L;
+    private static final long MAX_CONST_PRESSURE_ATTRIBUTE_ID = 4L;
+    private static final long MIN_COMP_PRESSURE_ATTRIBUTE_ID = 5L;
+    private static final long MAX_COMP_PRESSURE_ATTRIBUTE_ID = 6L;
+    private static final long MIN_CONST_SPEED_ATTRIBUTE_ID = 7L;
+    private static final long MAX_CONST_SPEED_ATTRIBUTE_ID = 8L;
+    private static final long MIN_CONST_FLOW_ATTRIBUTE_ID = 9L;
+    private static final long MAX_CONST_FLOW_ATTRIBUTE_ID = 10L;
+    private static final long MIN_CONST_TEMP_ATTRIBUTE_ID = 11L;
+    private static final long MAX_CONST_TEMP_ATTRIBUTE_ID = 12L;
+    private static final long PUMP_STATUS_ATTRIBUTE_ID = 16L;
+    private static final long EFFECTIVE_OPERATION_MODE_ATTRIBUTE_ID = 17L;
+    private static final long EFFECTIVE_CONTROL_MODE_ATTRIBUTE_ID = 18L;
+    private static final long CAPACITY_ATTRIBUTE_ID = 19L;
+    private static final long SPEED_ATTRIBUTE_ID = 20L;
+    private static final long LIFETIME_RUNNING_HOURS_ATTRIBUTE_ID = 21L;
+    private static final long POWER_ATTRIBUTE_ID = 22L;
+    private static final long LIFETIME_ENERGY_CONSUMED_ATTRIBUTE_ID = 23L;
+    private static final long OPERATION_MODE_ATTRIBUTE_ID = 32L;
+    private static final long CONTROL_MODE_ATTRIBUTE_ID = 33L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public PumpConfigurationAndControlCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface MaxPressureAttributeCallback {
+    public interface MaxPressureAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MaxSpeedAttributeCallback {
+    public interface MaxSpeedAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MaxFlowAttributeCallback {
+    public interface MaxFlowAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MinConstPressureAttributeCallback {
+    public interface MinConstPressureAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MaxConstPressureAttributeCallback {
+    public interface MaxConstPressureAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MinCompPressureAttributeCallback {
+    public interface MinCompPressureAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MaxCompPressureAttributeCallback {
+    public interface MaxCompPressureAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MinConstSpeedAttributeCallback {
+    public interface MinConstSpeedAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MaxConstSpeedAttributeCallback {
+    public interface MaxConstSpeedAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MinConstFlowAttributeCallback {
+    public interface MinConstFlowAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MaxConstFlowAttributeCallback {
+    public interface MaxConstFlowAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MinConstTempAttributeCallback {
+    public interface MinConstTempAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MaxConstTempAttributeCallback {
+    public interface MaxConstTempAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface CapacityAttributeCallback {
+    public interface CapacityAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface SpeedAttributeCallback {
+    public interface SpeedAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface LifetimeRunningHoursAttributeCallback {
+    public interface LifetimeRunningHoursAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface PowerAttributeCallback {
+    public interface PowerAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface LifetimeEnergyConsumedAttributeCallback {
+    public interface LifetimeEnergyConsumedAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readMaxPressureAttribute(
         MaxPressureAttributeCallback callback) {
-        readMaxPressureAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_PRESSURE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_PRESSURE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxPressureAttribute(
         MaxPressureAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_PRESSURE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_PRESSURE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxSpeedAttribute(
         MaxSpeedAttributeCallback callback) {
-        readMaxSpeedAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_SPEED_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_SPEED_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxSpeedAttribute(
         MaxSpeedAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_SPEED_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_SPEED_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxFlowAttribute(
         MaxFlowAttributeCallback callback) {
-        readMaxFlowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_FLOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_FLOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxFlowAttribute(
         MaxFlowAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxFlowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_FLOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_FLOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinConstPressureAttribute(
         MinConstPressureAttributeCallback callback) {
-        readMinConstPressureAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_CONST_PRESSURE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_CONST_PRESSURE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinConstPressureAttribute(
         MinConstPressureAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinConstPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_CONST_PRESSURE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_CONST_PRESSURE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxConstPressureAttribute(
         MaxConstPressureAttributeCallback callback) {
-        readMaxConstPressureAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_CONST_PRESSURE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_CONST_PRESSURE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxConstPressureAttribute(
         MaxConstPressureAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxConstPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_CONST_PRESSURE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_CONST_PRESSURE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinCompPressureAttribute(
         MinCompPressureAttributeCallback callback) {
-        readMinCompPressureAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_COMP_PRESSURE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_COMP_PRESSURE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinCompPressureAttribute(
         MinCompPressureAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinCompPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_COMP_PRESSURE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_COMP_PRESSURE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxCompPressureAttribute(
         MaxCompPressureAttributeCallback callback) {
-        readMaxCompPressureAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_COMP_PRESSURE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_COMP_PRESSURE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxCompPressureAttribute(
         MaxCompPressureAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxCompPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_COMP_PRESSURE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_COMP_PRESSURE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinConstSpeedAttribute(
         MinConstSpeedAttributeCallback callback) {
-        readMinConstSpeedAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_CONST_SPEED_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_CONST_SPEED_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinConstSpeedAttribute(
         MinConstSpeedAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinConstSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_CONST_SPEED_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_CONST_SPEED_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxConstSpeedAttribute(
         MaxConstSpeedAttributeCallback callback) {
-        readMaxConstSpeedAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_CONST_SPEED_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_CONST_SPEED_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxConstSpeedAttribute(
         MaxConstSpeedAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxConstSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_CONST_SPEED_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_CONST_SPEED_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinConstFlowAttribute(
         MinConstFlowAttributeCallback callback) {
-        readMinConstFlowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_CONST_FLOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_CONST_FLOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinConstFlowAttribute(
         MinConstFlowAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinConstFlowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_CONST_FLOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_CONST_FLOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxConstFlowAttribute(
         MaxConstFlowAttributeCallback callback) {
-        readMaxConstFlowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_CONST_FLOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_CONST_FLOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxConstFlowAttribute(
         MaxConstFlowAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxConstFlowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_CONST_FLOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_CONST_FLOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinConstTempAttribute(
         MinConstTempAttributeCallback callback) {
-        readMinConstTempAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_CONST_TEMP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_CONST_TEMP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinConstTempAttribute(
         MinConstTempAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinConstTempAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_CONST_TEMP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_CONST_TEMP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxConstTempAttribute(
         MaxConstTempAttributeCallback callback) {
-        readMaxConstTempAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_CONST_TEMP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_CONST_TEMP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxConstTempAttribute(
         MaxConstTempAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxConstTempAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_CONST_TEMP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_CONST_TEMP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPumpStatusAttribute(
         IntegerAttributeCallback callback) {
-        readPumpStatusAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PUMP_STATUS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PUMP_STATUS_ATTRIBUTE_ID, true);
     }
 
     public void subscribePumpStatusAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePumpStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PUMP_STATUS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PUMP_STATUS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEffectiveOperationModeAttribute(
         IntegerAttributeCallback callback) {
-        readEffectiveOperationModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EFFECTIVE_OPERATION_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EFFECTIVE_OPERATION_MODE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEffectiveOperationModeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEffectiveOperationModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EFFECTIVE_OPERATION_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EFFECTIVE_OPERATION_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEffectiveControlModeAttribute(
         IntegerAttributeCallback callback) {
-        readEffectiveControlModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EFFECTIVE_CONTROL_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EFFECTIVE_CONTROL_MODE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEffectiveControlModeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEffectiveControlModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EFFECTIVE_CONTROL_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EFFECTIVE_CONTROL_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCapacityAttribute(
         CapacityAttributeCallback callback) {
-        readCapacityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CAPACITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CAPACITY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCapacityAttribute(
         CapacityAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCapacityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CAPACITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CAPACITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSpeedAttribute(
         SpeedAttributeCallback callback) {
-        readSpeedAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SPEED_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SPEED_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSpeedAttribute(
         SpeedAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SPEED_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SPEED_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLifetimeRunningHoursAttribute(
         LifetimeRunningHoursAttributeCallback callback) {
-        readLifetimeRunningHoursAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LIFETIME_RUNNING_HOURS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LIFETIME_RUNNING_HOURS_ATTRIBUTE_ID, true);
     }
 
     public void writeLifetimeRunningHoursAttribute(DefaultClusterCallback callback, Long value) {
-        writeLifetimeRunningHoursAttribute(chipClusterPtr, callback, value, null);
+      writeLifetimeRunningHoursAttribute(callback, value, 0);
     }
 
     public void writeLifetimeRunningHoursAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeLifetimeRunningHoursAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LIFETIME_RUNNING_HOURS_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeLifetimeRunningHoursAttribute(
         LifetimeRunningHoursAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLifetimeRunningHoursAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LIFETIME_RUNNING_HOURS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LIFETIME_RUNNING_HOURS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPowerAttribute(
         PowerAttributeCallback callback) {
-        readPowerAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, POWER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, POWER_ATTRIBUTE_ID, true);
     }
 
     public void subscribePowerAttribute(
         PowerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, POWER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, POWER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLifetimeEnergyConsumedAttribute(
         LifetimeEnergyConsumedAttributeCallback callback) {
-        readLifetimeEnergyConsumedAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LIFETIME_ENERGY_CONSUMED_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LIFETIME_ENERGY_CONSUMED_ATTRIBUTE_ID, true);
     }
 
     public void writeLifetimeEnergyConsumedAttribute(DefaultClusterCallback callback, Long value) {
-        writeLifetimeEnergyConsumedAttribute(chipClusterPtr, callback, value, null);
+      writeLifetimeEnergyConsumedAttribute(callback, value, 0);
     }
 
     public void writeLifetimeEnergyConsumedAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeLifetimeEnergyConsumedAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LIFETIME_ENERGY_CONSUMED_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeLifetimeEnergyConsumedAttribute(
         LifetimeEnergyConsumedAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLifetimeEnergyConsumedAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LIFETIME_ENERGY_CONSUMED_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LIFETIME_ENERGY_CONSUMED_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOperationModeAttribute(
         IntegerAttributeCallback callback) {
-        readOperationModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPERATION_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OPERATION_MODE_ATTRIBUTE_ID, true);
     }
 
     public void writeOperationModeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOperationModeAttribute(chipClusterPtr, callback, value, null);
+      writeOperationModeAttribute(callback, value, 0);
     }
 
     public void writeOperationModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOperationModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), OPERATION_MODE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOperationModeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOperationModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPERATION_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OPERATION_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readControlModeAttribute(
         IntegerAttributeCallback callback) {
-        readControlModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CONTROL_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CONTROL_MODE_ATTRIBUTE_ID, true);
     }
 
     public void writeControlModeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeControlModeAttribute(chipClusterPtr, callback, value, null);
+      writeControlModeAttribute(callback, value, 0);
     }
 
     public void writeControlModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeControlModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), CONTROL_MODE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeControlModeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeControlModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CONTROL_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CONTROL_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readMaxPressureAttribute(long chipClusterPtr, MaxPressureAttributeCallback callback);
-
-    private native void subscribeMaxPressureAttribute(long chipClusterPtr, MaxPressureAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMaxSpeedAttribute(long chipClusterPtr, MaxSpeedAttributeCallback callback);
-
-    private native void subscribeMaxSpeedAttribute(long chipClusterPtr, MaxSpeedAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMaxFlowAttribute(long chipClusterPtr, MaxFlowAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeMaxFlowAttribute(long chipClusterPtr, MaxFlowAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMinConstPressureAttribute(long chipClusterPtr, MinConstPressureAttributeCallback callback);
-
-    private native void subscribeMinConstPressureAttribute(long chipClusterPtr, MinConstPressureAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMaxConstPressureAttribute(long chipClusterPtr, MaxConstPressureAttributeCallback callback);
-
-    private native void subscribeMaxConstPressureAttribute(long chipClusterPtr, MaxConstPressureAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMinCompPressureAttribute(long chipClusterPtr, MinCompPressureAttributeCallback callback);
-
-    private native void subscribeMinCompPressureAttribute(long chipClusterPtr, MinCompPressureAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMaxCompPressureAttribute(long chipClusterPtr, MaxCompPressureAttributeCallback callback);
-
-    private native void subscribeMaxCompPressureAttribute(long chipClusterPtr, MaxCompPressureAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMinConstSpeedAttribute(long chipClusterPtr, MinConstSpeedAttributeCallback callback);
-
-    private native void subscribeMinConstSpeedAttribute(long chipClusterPtr, MinConstSpeedAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMaxConstSpeedAttribute(long chipClusterPtr, MaxConstSpeedAttributeCallback callback);
-
-    private native void subscribeMaxConstSpeedAttribute(long chipClusterPtr, MaxConstSpeedAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMinConstFlowAttribute(long chipClusterPtr, MinConstFlowAttributeCallback callback);
-
-    private native void subscribeMinConstFlowAttribute(long chipClusterPtr, MinConstFlowAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMaxConstFlowAttribute(long chipClusterPtr, MaxConstFlowAttributeCallback callback);
-
-    private native void subscribeMaxConstFlowAttribute(long chipClusterPtr, MaxConstFlowAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMinConstTempAttribute(long chipClusterPtr, MinConstTempAttributeCallback callback);
-
-    private native void subscribeMinConstTempAttribute(long chipClusterPtr, MinConstTempAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMaxConstTempAttribute(long chipClusterPtr, MaxConstTempAttributeCallback callback);
-
-    private native void subscribeMaxConstTempAttribute(long chipClusterPtr, MaxConstTempAttributeCallback 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, CapacityAttributeCallback callback);
-
-    private native void subscribeCapacityAttribute(long chipClusterPtr, CapacityAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSpeedAttribute(long chipClusterPtr, SpeedAttributeCallback callback);
-
-    private native void subscribeSpeedAttribute(long chipClusterPtr, SpeedAttributeCallback 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, PowerAttributeCallback callback);
-
-    private native void subscribePowerAttribute(long chipClusterPtr, PowerAttributeCallback 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 readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class ThermostatCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 513L;
 
+    private static final long LOCAL_TEMPERATURE_ATTRIBUTE_ID = 0L;
+    private static final long OUTDOOR_TEMPERATURE_ATTRIBUTE_ID = 1L;
+    private static final long OCCUPANCY_ATTRIBUTE_ID = 2L;
+    private static final long ABS_MIN_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID = 3L;
+    private static final long ABS_MAX_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID = 4L;
+    private static final long ABS_MIN_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID = 5L;
+    private static final long ABS_MAX_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID = 6L;
+    private static final long P_I_COOLING_DEMAND_ATTRIBUTE_ID = 7L;
+    private static final long P_I_HEATING_DEMAND_ATTRIBUTE_ID = 8L;
+    private static final long H_V_A_C_SYSTEM_TYPE_CONFIGURATION_ATTRIBUTE_ID = 9L;
+    private static final long LOCAL_TEMPERATURE_CALIBRATION_ATTRIBUTE_ID = 16L;
+    private static final long OCCUPIED_COOLING_SETPOINT_ATTRIBUTE_ID = 17L;
+    private static final long OCCUPIED_HEATING_SETPOINT_ATTRIBUTE_ID = 18L;
+    private static final long UNOCCUPIED_COOLING_SETPOINT_ATTRIBUTE_ID = 19L;
+    private static final long UNOCCUPIED_HEATING_SETPOINT_ATTRIBUTE_ID = 20L;
+    private static final long MIN_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID = 21L;
+    private static final long MAX_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID = 22L;
+    private static final long MIN_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID = 23L;
+    private static final long MAX_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID = 24L;
+    private static final long MIN_SETPOINT_DEAD_BAND_ATTRIBUTE_ID = 25L;
+    private static final long REMOTE_SENSING_ATTRIBUTE_ID = 26L;
+    private static final long CONTROL_SEQUENCE_OF_OPERATION_ATTRIBUTE_ID = 27L;
+    private static final long SYSTEM_MODE_ATTRIBUTE_ID = 28L;
+    private static final long THERMOSTAT_RUNNING_MODE_ATTRIBUTE_ID = 30L;
+    private static final long START_OF_WEEK_ATTRIBUTE_ID = 32L;
+    private static final long NUMBER_OF_WEEKLY_TRANSITIONS_ATTRIBUTE_ID = 33L;
+    private static final long NUMBER_OF_DAILY_TRANSITIONS_ATTRIBUTE_ID = 34L;
+    private static final long TEMPERATURE_SETPOINT_HOLD_ATTRIBUTE_ID = 35L;
+    private static final long TEMPERATURE_SETPOINT_HOLD_DURATION_ATTRIBUTE_ID = 36L;
+    private static final long THERMOSTAT_PROGRAMMING_OPERATION_MODE_ATTRIBUTE_ID = 37L;
+    private static final long THERMOSTAT_RUNNING_STATE_ATTRIBUTE_ID = 41L;
+    private static final long SETPOINT_CHANGE_SOURCE_ATTRIBUTE_ID = 48L;
+    private static final long SETPOINT_CHANGE_AMOUNT_ATTRIBUTE_ID = 49L;
+    private static final long SETPOINT_CHANGE_SOURCE_TIMESTAMP_ATTRIBUTE_ID = 50L;
+    private static final long OCCUPIED_SETBACK_ATTRIBUTE_ID = 52L;
+    private static final long OCCUPIED_SETBACK_MIN_ATTRIBUTE_ID = 53L;
+    private static final long OCCUPIED_SETBACK_MAX_ATTRIBUTE_ID = 54L;
+    private static final long UNOCCUPIED_SETBACK_ATTRIBUTE_ID = 55L;
+    private static final long UNOCCUPIED_SETBACK_MIN_ATTRIBUTE_ID = 56L;
+    private static final long UNOCCUPIED_SETBACK_MAX_ATTRIBUTE_ID = 57L;
+    private static final long EMERGENCY_HEAT_DELTA_ATTRIBUTE_ID = 58L;
+    private static final long A_C_TYPE_ATTRIBUTE_ID = 64L;
+    private static final long A_C_CAPACITY_ATTRIBUTE_ID = 65L;
+    private static final long A_C_REFRIGERANT_TYPE_ATTRIBUTE_ID = 66L;
+    private static final long A_C_COMPRESSOR_TYPE_ATTRIBUTE_ID = 67L;
+    private static final long A_C_ERROR_CODE_ATTRIBUTE_ID = 68L;
+    private static final long A_C_LOUVER_POSITION_ATTRIBUTE_ID = 69L;
+    private static final long A_C_COIL_TEMPERATURE_ATTRIBUTE_ID = 70L;
+    private static final long A_C_CAPACITYFORMAT_ATTRIBUTE_ID = 71L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public ThermostatCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void setpointRaiseLower(DefaultClusterCallback callback, Integer mode, Integer amount) {
-      setpointRaiseLower(chipClusterPtr, callback, mode, amount, null);
+      setpointRaiseLower(callback, mode, amount, 0);
     }
 
     public void setpointRaiseLower(DefaultClusterCallback callback, Integer mode, Integer amount, int timedInvokeTimeoutMs) {
-      setpointRaiseLower(chipClusterPtr, callback, mode, amount, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long modeFieldID = 0L;
+      BaseTLVType modetlvValue = new UIntType(mode);
+      elements.add(new StructElement(modeFieldID, modetlvValue));
+
+      final long amountFieldID = 1L;
+      BaseTLVType amounttlvValue = new IntType(amount);
+      elements.add(new StructElement(amountFieldID, amounttlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void setWeeklySchedule(DefaultClusterCallback callback, Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList<ChipStructs.ThermostatClusterThermostatScheduleTransition> transitions) {
-      setWeeklySchedule(chipClusterPtr, callback, numberOfTransitionsForSequence, dayOfWeekForSequence, modeForSequence, transitions, null);
+      setWeeklySchedule(callback, numberOfTransitionsForSequence, dayOfWeekForSequence, modeForSequence, transitions, 0);
     }
 
     public void setWeeklySchedule(DefaultClusterCallback callback, Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList<ChipStructs.ThermostatClusterThermostatScheduleTransition> transitions, int timedInvokeTimeoutMs) {
-      setWeeklySchedule(chipClusterPtr, callback, numberOfTransitionsForSequence, dayOfWeekForSequence, modeForSequence, transitions, timedInvokeTimeoutMs);
+      final long commandId = 1L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long numberOfTransitionsForSequenceFieldID = 0L;
+      BaseTLVType numberOfTransitionsForSequencetlvValue = new UIntType(numberOfTransitionsForSequence);
+      elements.add(new StructElement(numberOfTransitionsForSequenceFieldID, numberOfTransitionsForSequencetlvValue));
+
+      final long dayOfWeekForSequenceFieldID = 1L;
+      BaseTLVType dayOfWeekForSequencetlvValue = new UIntType(dayOfWeekForSequence);
+      elements.add(new StructElement(dayOfWeekForSequenceFieldID, dayOfWeekForSequencetlvValue));
+
+      final long modeForSequenceFieldID = 2L;
+      BaseTLVType modeForSequencetlvValue = new UIntType(modeForSequence);
+      elements.add(new StructElement(modeForSequenceFieldID, modeForSequencetlvValue));
+
+      final long transitionsFieldID = 3L;
+      BaseTLVType transitionstlvValue = ArrayType.generateArrayType(transitions, (elementtransitions) -> elementtransitions.encodeTlv());
+      elements.add(new StructElement(transitionsFieldID, transitionstlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void getWeeklySchedule(GetWeeklyScheduleResponseCallback callback, Integer daysToReturn, Integer modeToReturn) {
-      getWeeklySchedule(chipClusterPtr, callback, daysToReturn, modeToReturn, null);
+      getWeeklySchedule(callback, daysToReturn, modeToReturn, 0);
     }
 
     public void getWeeklySchedule(GetWeeklyScheduleResponseCallback callback, Integer daysToReturn, Integer modeToReturn, int timedInvokeTimeoutMs) {
-      getWeeklySchedule(chipClusterPtr, callback, daysToReturn, modeToReturn, timedInvokeTimeoutMs);
+      final long commandId = 2L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long daysToReturnFieldID = 0L;
+      BaseTLVType daysToReturntlvValue = new UIntType(daysToReturn);
+      elements.add(new StructElement(daysToReturnFieldID, daysToReturntlvValue));
+
+      final long modeToReturnFieldID = 1L;
+      BaseTLVType modeToReturntlvValue = new UIntType(modeToReturn);
+      elements.add(new StructElement(modeToReturnFieldID, modeToReturntlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long numberOfTransitionsForSequenceFieldID = 0L;
+          Integer numberOfTransitionsForSequence = null;
+          final long dayOfWeekForSequenceFieldID = 1L;
+          Integer dayOfWeekForSequence = null;
+          final long modeForSequenceFieldID = 2L;
+          Integer modeForSequence = null;
+          final long transitionsFieldID = 3L;
+          ArrayList<ChipStructs.ThermostatClusterThermostatScheduleTransition> transitions = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == numberOfTransitionsForSequenceFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                numberOfTransitionsForSequence = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == dayOfWeekForSequenceFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                dayOfWeekForSequence = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == modeForSequenceFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                modeForSequence = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == transitionsFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+                ArrayType castingValue = element.value(ArrayType.class);
+                transitions = castingValue.map((elementcastingValue) -> ChipStructs.ThermostatClusterThermostatScheduleTransition.decodeTlv(elementcastingValue));
+              }
+            }
+          }
+          callback.onSuccess(numberOfTransitionsForSequence, dayOfWeekForSequence, modeForSequence, transitions);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void clearWeeklySchedule(DefaultClusterCallback callback) {
-      clearWeeklySchedule(chipClusterPtr, callback, null);
+      clearWeeklySchedule(callback, 0);
     }
 
     public void clearWeeklySchedule(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      clearWeeklySchedule(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
+      final long commandId = 3L;
 
-    private native void setpointRaiseLower(long chipClusterPtr, DefaultClusterCallback callback, Integer mode, Integer amount, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void setWeeklySchedule(long chipClusterPtr, DefaultClusterCallback callback, Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList<ChipStructs.ThermostatClusterThermostatScheduleTransition> transitions, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void getWeeklySchedule(long chipClusterPtr, GetWeeklyScheduleResponseCallback callback, Integer daysToReturn, Integer modeToReturn, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void clearWeeklySchedule(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface GetWeeklyScheduleResponseCallback {
+    public interface GetWeeklyScheduleResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList<ChipStructs.ThermostatClusterThermostatScheduleTransition> transitions);
-      void onError(Exception error);
     }
 
-    public interface LocalTemperatureAttributeCallback {
+    public interface LocalTemperatureAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface OutdoorTemperatureAttributeCallback {
+    public interface OutdoorTemperatureAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface TemperatureSetpointHoldDurationAttributeCallback {
+    public interface TemperatureSetpointHoldDurationAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface SetpointChangeAmountAttributeCallback {
+    public interface SetpointChangeAmountAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface OccupiedSetbackAttributeCallback {
+    public interface OccupiedSetbackAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface OccupiedSetbackMinAttributeCallback {
+    public interface OccupiedSetbackMinAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface OccupiedSetbackMaxAttributeCallback {
+    public interface OccupiedSetbackMaxAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface UnoccupiedSetbackAttributeCallback {
+    public interface UnoccupiedSetbackAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface UnoccupiedSetbackMinAttributeCallback {
+    public interface UnoccupiedSetbackMinAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface UnoccupiedSetbackMaxAttributeCallback {
+    public interface UnoccupiedSetbackMaxAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ACCoilTemperatureAttributeCallback {
+    public interface ACCoilTemperatureAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readLocalTemperatureAttribute(
         LocalTemperatureAttributeCallback callback) {
-        readLocalTemperatureAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOCAL_TEMPERATURE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LOCAL_TEMPERATURE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLocalTemperatureAttribute(
         LocalTemperatureAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLocalTemperatureAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOCAL_TEMPERATURE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LOCAL_TEMPERATURE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOutdoorTemperatureAttribute(
         OutdoorTemperatureAttributeCallback callback) {
-        readOutdoorTemperatureAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OUTDOOR_TEMPERATURE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OUTDOOR_TEMPERATURE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeOutdoorTemperatureAttribute(
         OutdoorTemperatureAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOutdoorTemperatureAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OUTDOOR_TEMPERATURE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OUTDOOR_TEMPERATURE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOccupancyAttribute(
         IntegerAttributeCallback callback) {
-        readOccupancyAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OCCUPANCY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OCCUPANCY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeOccupancyAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOccupancyAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OCCUPANCY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OCCUPANCY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAbsMinHeatSetpointLimitAttribute(
         IntegerAttributeCallback callback) {
-        readAbsMinHeatSetpointLimitAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ABS_MIN_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ABS_MIN_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAbsMinHeatSetpointLimitAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAbsMinHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ABS_MIN_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ABS_MIN_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAbsMaxHeatSetpointLimitAttribute(
         IntegerAttributeCallback callback) {
-        readAbsMaxHeatSetpointLimitAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ABS_MAX_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ABS_MAX_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAbsMaxHeatSetpointLimitAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAbsMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ABS_MAX_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ABS_MAX_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAbsMinCoolSetpointLimitAttribute(
         IntegerAttributeCallback callback) {
-        readAbsMinCoolSetpointLimitAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ABS_MIN_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ABS_MIN_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAbsMinCoolSetpointLimitAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAbsMinCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ABS_MIN_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ABS_MIN_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAbsMaxCoolSetpointLimitAttribute(
         IntegerAttributeCallback callback) {
-        readAbsMaxCoolSetpointLimitAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ABS_MAX_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ABS_MAX_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAbsMaxCoolSetpointLimitAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAbsMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ABS_MAX_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ABS_MAX_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPICoolingDemandAttribute(
         IntegerAttributeCallback callback) {
-        readPICoolingDemandAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, P_I_COOLING_DEMAND_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, P_I_COOLING_DEMAND_ATTRIBUTE_ID, true);
     }
 
     public void subscribePICoolingDemandAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePICoolingDemandAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, P_I_COOLING_DEMAND_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, P_I_COOLING_DEMAND_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPIHeatingDemandAttribute(
         IntegerAttributeCallback callback) {
-        readPIHeatingDemandAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, P_I_HEATING_DEMAND_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, P_I_HEATING_DEMAND_ATTRIBUTE_ID, true);
     }
 
     public void subscribePIHeatingDemandAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePIHeatingDemandAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, P_I_HEATING_DEMAND_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, P_I_HEATING_DEMAND_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readHVACSystemTypeConfigurationAttribute(
         IntegerAttributeCallback callback) {
-        readHVACSystemTypeConfigurationAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, H_V_A_C_SYSTEM_TYPE_CONFIGURATION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, H_V_A_C_SYSTEM_TYPE_CONFIGURATION_ATTRIBUTE_ID, true);
     }
 
     public void writeHVACSystemTypeConfigurationAttribute(DefaultClusterCallback callback, Integer value) {
-        writeHVACSystemTypeConfigurationAttribute(chipClusterPtr, callback, value, null);
+      writeHVACSystemTypeConfigurationAttribute(callback, value, 0);
     }
 
     public void writeHVACSystemTypeConfigurationAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeHVACSystemTypeConfigurationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), H_V_A_C_SYSTEM_TYPE_CONFIGURATION_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeHVACSystemTypeConfigurationAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeHVACSystemTypeConfigurationAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, H_V_A_C_SYSTEM_TYPE_CONFIGURATION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, H_V_A_C_SYSTEM_TYPE_CONFIGURATION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLocalTemperatureCalibrationAttribute(
         IntegerAttributeCallback callback) {
-        readLocalTemperatureCalibrationAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOCAL_TEMPERATURE_CALIBRATION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LOCAL_TEMPERATURE_CALIBRATION_ATTRIBUTE_ID, true);
     }
 
     public void writeLocalTemperatureCalibrationAttribute(DefaultClusterCallback callback, Integer value) {
-        writeLocalTemperatureCalibrationAttribute(chipClusterPtr, callback, value, null);
+      writeLocalTemperatureCalibrationAttribute(callback, value, 0);
     }
 
     public void writeLocalTemperatureCalibrationAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeLocalTemperatureCalibrationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new IntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LOCAL_TEMPERATURE_CALIBRATION_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeLocalTemperatureCalibrationAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLocalTemperatureCalibrationAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LOCAL_TEMPERATURE_CALIBRATION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LOCAL_TEMPERATURE_CALIBRATION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOccupiedCoolingSetpointAttribute(
         IntegerAttributeCallback callback) {
-        readOccupiedCoolingSetpointAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OCCUPIED_COOLING_SETPOINT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OCCUPIED_COOLING_SETPOINT_ATTRIBUTE_ID, true);
     }
 
     public void writeOccupiedCoolingSetpointAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOccupiedCoolingSetpointAttribute(chipClusterPtr, callback, value, null);
+      writeOccupiedCoolingSetpointAttribute(callback, value, 0);
     }
 
     public void writeOccupiedCoolingSetpointAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOccupiedCoolingSetpointAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new IntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), OCCUPIED_COOLING_SETPOINT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOccupiedCoolingSetpointAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOccupiedCoolingSetpointAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OCCUPIED_COOLING_SETPOINT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OCCUPIED_COOLING_SETPOINT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOccupiedHeatingSetpointAttribute(
         IntegerAttributeCallback callback) {
-        readOccupiedHeatingSetpointAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OCCUPIED_HEATING_SETPOINT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OCCUPIED_HEATING_SETPOINT_ATTRIBUTE_ID, true);
     }
 
     public void writeOccupiedHeatingSetpointAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOccupiedHeatingSetpointAttribute(chipClusterPtr, callback, value, null);
+      writeOccupiedHeatingSetpointAttribute(callback, value, 0);
     }
 
     public void writeOccupiedHeatingSetpointAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOccupiedHeatingSetpointAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new IntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), OCCUPIED_HEATING_SETPOINT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOccupiedHeatingSetpointAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOccupiedHeatingSetpointAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OCCUPIED_HEATING_SETPOINT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OCCUPIED_HEATING_SETPOINT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUnoccupiedCoolingSetpointAttribute(
         IntegerAttributeCallback callback) {
-        readUnoccupiedCoolingSetpointAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNOCCUPIED_COOLING_SETPOINT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UNOCCUPIED_COOLING_SETPOINT_ATTRIBUTE_ID, true);
     }
 
     public void writeUnoccupiedCoolingSetpointAttribute(DefaultClusterCallback callback, Integer value) {
-        writeUnoccupiedCoolingSetpointAttribute(chipClusterPtr, callback, value, null);
+      writeUnoccupiedCoolingSetpointAttribute(callback, value, 0);
     }
 
     public void writeUnoccupiedCoolingSetpointAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeUnoccupiedCoolingSetpointAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new IntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), UNOCCUPIED_COOLING_SETPOINT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeUnoccupiedCoolingSetpointAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUnoccupiedCoolingSetpointAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNOCCUPIED_COOLING_SETPOINT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UNOCCUPIED_COOLING_SETPOINT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUnoccupiedHeatingSetpointAttribute(
         IntegerAttributeCallback callback) {
-        readUnoccupiedHeatingSetpointAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNOCCUPIED_HEATING_SETPOINT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UNOCCUPIED_HEATING_SETPOINT_ATTRIBUTE_ID, true);
     }
 
     public void writeUnoccupiedHeatingSetpointAttribute(DefaultClusterCallback callback, Integer value) {
-        writeUnoccupiedHeatingSetpointAttribute(chipClusterPtr, callback, value, null);
+      writeUnoccupiedHeatingSetpointAttribute(callback, value, 0);
     }
 
     public void writeUnoccupiedHeatingSetpointAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeUnoccupiedHeatingSetpointAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new IntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), UNOCCUPIED_HEATING_SETPOINT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeUnoccupiedHeatingSetpointAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUnoccupiedHeatingSetpointAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNOCCUPIED_HEATING_SETPOINT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UNOCCUPIED_HEATING_SETPOINT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinHeatSetpointLimitAttribute(
         IntegerAttributeCallback callback) {
-        readMinHeatSetpointLimitAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID, true);
     }
 
     public void writeMinHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) {
-        writeMinHeatSetpointLimitAttribute(chipClusterPtr, callback, value, null);
+      writeMinHeatSetpointLimitAttribute(callback, value, 0);
     }
 
     public void writeMinHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeMinHeatSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new IntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), MIN_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeMinHeatSetpointLimitAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxHeatSetpointLimitAttribute(
         IntegerAttributeCallback callback) {
-        readMaxHeatSetpointLimitAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID, true);
     }
 
     public void writeMaxHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) {
-        writeMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, value, null);
+      writeMaxHeatSetpointLimitAttribute(callback, value, 0);
     }
 
     public void writeMaxHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new IntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), MAX_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeMaxHeatSetpointLimitAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_HEAT_SETPOINT_LIMIT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinCoolSetpointLimitAttribute(
         IntegerAttributeCallback callback) {
-        readMinCoolSetpointLimitAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID, true);
     }
 
     public void writeMinCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) {
-        writeMinCoolSetpointLimitAttribute(chipClusterPtr, callback, value, null);
+      writeMinCoolSetpointLimitAttribute(callback, value, 0);
     }
 
     public void writeMinCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeMinCoolSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new IntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), MIN_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeMinCoolSetpointLimitAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxCoolSetpointLimitAttribute(
         IntegerAttributeCallback callback) {
-        readMaxCoolSetpointLimitAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID, true);
     }
 
     public void writeMaxCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) {
-        writeMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, value, null);
+      writeMaxCoolSetpointLimitAttribute(callback, value, 0);
     }
 
     public void writeMaxCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new IntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), MAX_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeMaxCoolSetpointLimitAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_COOL_SETPOINT_LIMIT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinSetpointDeadBandAttribute(
         IntegerAttributeCallback callback) {
-        readMinSetpointDeadBandAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_SETPOINT_DEAD_BAND_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_SETPOINT_DEAD_BAND_ATTRIBUTE_ID, true);
     }
 
     public void writeMinSetpointDeadBandAttribute(DefaultClusterCallback callback, Integer value) {
-        writeMinSetpointDeadBandAttribute(chipClusterPtr, callback, value, null);
+      writeMinSetpointDeadBandAttribute(callback, value, 0);
     }
 
     public void writeMinSetpointDeadBandAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeMinSetpointDeadBandAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new IntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), MIN_SETPOINT_DEAD_BAND_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeMinSetpointDeadBandAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinSetpointDeadBandAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_SETPOINT_DEAD_BAND_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_SETPOINT_DEAD_BAND_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRemoteSensingAttribute(
         IntegerAttributeCallback callback) {
-        readRemoteSensingAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REMOTE_SENSING_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, REMOTE_SENSING_ATTRIBUTE_ID, true);
     }
 
     public void writeRemoteSensingAttribute(DefaultClusterCallback callback, Integer value) {
-        writeRemoteSensingAttribute(chipClusterPtr, callback, value, null);
+      writeRemoteSensingAttribute(callback, value, 0);
     }
 
     public void writeRemoteSensingAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeRemoteSensingAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), REMOTE_SENSING_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeRemoteSensingAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRemoteSensingAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REMOTE_SENSING_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, REMOTE_SENSING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readControlSequenceOfOperationAttribute(
         IntegerAttributeCallback callback) {
-        readControlSequenceOfOperationAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CONTROL_SEQUENCE_OF_OPERATION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CONTROL_SEQUENCE_OF_OPERATION_ATTRIBUTE_ID, true);
     }
 
     public void writeControlSequenceOfOperationAttribute(DefaultClusterCallback callback, Integer value) {
-        writeControlSequenceOfOperationAttribute(chipClusterPtr, callback, value, null);
+      writeControlSequenceOfOperationAttribute(callback, value, 0);
     }
 
     public void writeControlSequenceOfOperationAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeControlSequenceOfOperationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), CONTROL_SEQUENCE_OF_OPERATION_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeControlSequenceOfOperationAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeControlSequenceOfOperationAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CONTROL_SEQUENCE_OF_OPERATION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CONTROL_SEQUENCE_OF_OPERATION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSystemModeAttribute(
         IntegerAttributeCallback callback) {
-        readSystemModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SYSTEM_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SYSTEM_MODE_ATTRIBUTE_ID, true);
     }
 
     public void writeSystemModeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeSystemModeAttribute(chipClusterPtr, callback, value, null);
+      writeSystemModeAttribute(callback, value, 0);
     }
 
     public void writeSystemModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeSystemModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), SYSTEM_MODE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeSystemModeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSystemModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SYSTEM_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SYSTEM_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readThermostatRunningModeAttribute(
         IntegerAttributeCallback callback) {
-        readThermostatRunningModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, THERMOSTAT_RUNNING_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, THERMOSTAT_RUNNING_MODE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeThermostatRunningModeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeThermostatRunningModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, THERMOSTAT_RUNNING_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, THERMOSTAT_RUNNING_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readStartOfWeekAttribute(
         IntegerAttributeCallback callback) {
-        readStartOfWeekAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, START_OF_WEEK_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, START_OF_WEEK_ATTRIBUTE_ID, true);
     }
 
     public void subscribeStartOfWeekAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeStartOfWeekAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, START_OF_WEEK_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, START_OF_WEEK_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readNumberOfWeeklyTransitionsAttribute(
         IntegerAttributeCallback callback) {
-        readNumberOfWeeklyTransitionsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_WEEKLY_TRANSITIONS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NUMBER_OF_WEEKLY_TRANSITIONS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeNumberOfWeeklyTransitionsAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNumberOfWeeklyTransitionsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_WEEKLY_TRANSITIONS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NUMBER_OF_WEEKLY_TRANSITIONS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readNumberOfDailyTransitionsAttribute(
         IntegerAttributeCallback callback) {
-        readNumberOfDailyTransitionsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_DAILY_TRANSITIONS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NUMBER_OF_DAILY_TRANSITIONS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeNumberOfDailyTransitionsAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNumberOfDailyTransitionsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_DAILY_TRANSITIONS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NUMBER_OF_DAILY_TRANSITIONS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTemperatureSetpointHoldAttribute(
         IntegerAttributeCallback callback) {
-        readTemperatureSetpointHoldAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TEMPERATURE_SETPOINT_HOLD_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TEMPERATURE_SETPOINT_HOLD_ATTRIBUTE_ID, true);
     }
 
     public void writeTemperatureSetpointHoldAttribute(DefaultClusterCallback callback, Integer value) {
-        writeTemperatureSetpointHoldAttribute(chipClusterPtr, callback, value, null);
+      writeTemperatureSetpointHoldAttribute(callback, value, 0);
     }
 
     public void writeTemperatureSetpointHoldAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeTemperatureSetpointHoldAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), TEMPERATURE_SETPOINT_HOLD_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeTemperatureSetpointHoldAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTemperatureSetpointHoldAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TEMPERATURE_SETPOINT_HOLD_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TEMPERATURE_SETPOINT_HOLD_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTemperatureSetpointHoldDurationAttribute(
         TemperatureSetpointHoldDurationAttributeCallback callback) {
-        readTemperatureSetpointHoldDurationAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TEMPERATURE_SETPOINT_HOLD_DURATION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TEMPERATURE_SETPOINT_HOLD_DURATION_ATTRIBUTE_ID, true);
     }
 
     public void writeTemperatureSetpointHoldDurationAttribute(DefaultClusterCallback callback, Integer value) {
-        writeTemperatureSetpointHoldDurationAttribute(chipClusterPtr, callback, value, null);
+      writeTemperatureSetpointHoldDurationAttribute(callback, value, 0);
     }
 
     public void writeTemperatureSetpointHoldDurationAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeTemperatureSetpointHoldDurationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), TEMPERATURE_SETPOINT_HOLD_DURATION_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeTemperatureSetpointHoldDurationAttribute(
         TemperatureSetpointHoldDurationAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTemperatureSetpointHoldDurationAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TEMPERATURE_SETPOINT_HOLD_DURATION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TEMPERATURE_SETPOINT_HOLD_DURATION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readThermostatProgrammingOperationModeAttribute(
         IntegerAttributeCallback callback) {
-        readThermostatProgrammingOperationModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, THERMOSTAT_PROGRAMMING_OPERATION_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, THERMOSTAT_PROGRAMMING_OPERATION_MODE_ATTRIBUTE_ID, true);
     }
 
     public void writeThermostatProgrammingOperationModeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeThermostatProgrammingOperationModeAttribute(chipClusterPtr, callback, value, null);
+      writeThermostatProgrammingOperationModeAttribute(callback, value, 0);
     }
 
     public void writeThermostatProgrammingOperationModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeThermostatProgrammingOperationModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), THERMOSTAT_PROGRAMMING_OPERATION_MODE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeThermostatProgrammingOperationModeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeThermostatProgrammingOperationModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, THERMOSTAT_PROGRAMMING_OPERATION_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, THERMOSTAT_PROGRAMMING_OPERATION_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readThermostatRunningStateAttribute(
         IntegerAttributeCallback callback) {
-        readThermostatRunningStateAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, THERMOSTAT_RUNNING_STATE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, THERMOSTAT_RUNNING_STATE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeThermostatRunningStateAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeThermostatRunningStateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, THERMOSTAT_RUNNING_STATE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, THERMOSTAT_RUNNING_STATE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSetpointChangeSourceAttribute(
         IntegerAttributeCallback callback) {
-        readSetpointChangeSourceAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SETPOINT_CHANGE_SOURCE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SETPOINT_CHANGE_SOURCE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSetpointChangeSourceAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSetpointChangeSourceAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SETPOINT_CHANGE_SOURCE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SETPOINT_CHANGE_SOURCE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSetpointChangeAmountAttribute(
         SetpointChangeAmountAttributeCallback callback) {
-        readSetpointChangeAmountAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SETPOINT_CHANGE_AMOUNT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SETPOINT_CHANGE_AMOUNT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSetpointChangeAmountAttribute(
         SetpointChangeAmountAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSetpointChangeAmountAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SETPOINT_CHANGE_AMOUNT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SETPOINT_CHANGE_AMOUNT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSetpointChangeSourceTimestampAttribute(
         LongAttributeCallback callback) {
-        readSetpointChangeSourceTimestampAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SETPOINT_CHANGE_SOURCE_TIMESTAMP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SETPOINT_CHANGE_SOURCE_TIMESTAMP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSetpointChangeSourceTimestampAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSetpointChangeSourceTimestampAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SETPOINT_CHANGE_SOURCE_TIMESTAMP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SETPOINT_CHANGE_SOURCE_TIMESTAMP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOccupiedSetbackAttribute(
         OccupiedSetbackAttributeCallback callback) {
-        readOccupiedSetbackAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OCCUPIED_SETBACK_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OCCUPIED_SETBACK_ATTRIBUTE_ID, true);
     }
 
     public void writeOccupiedSetbackAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOccupiedSetbackAttribute(chipClusterPtr, callback, value, null);
+      writeOccupiedSetbackAttribute(callback, value, 0);
     }
 
     public void writeOccupiedSetbackAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOccupiedSetbackAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), OCCUPIED_SETBACK_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOccupiedSetbackAttribute(
         OccupiedSetbackAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOccupiedSetbackAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OCCUPIED_SETBACK_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OCCUPIED_SETBACK_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOccupiedSetbackMinAttribute(
         OccupiedSetbackMinAttributeCallback callback) {
-        readOccupiedSetbackMinAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OCCUPIED_SETBACK_MIN_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OCCUPIED_SETBACK_MIN_ATTRIBUTE_ID, true);
     }
 
     public void subscribeOccupiedSetbackMinAttribute(
         OccupiedSetbackMinAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOccupiedSetbackMinAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OCCUPIED_SETBACK_MIN_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OCCUPIED_SETBACK_MIN_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOccupiedSetbackMaxAttribute(
         OccupiedSetbackMaxAttributeCallback callback) {
-        readOccupiedSetbackMaxAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OCCUPIED_SETBACK_MAX_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OCCUPIED_SETBACK_MAX_ATTRIBUTE_ID, true);
     }
 
     public void subscribeOccupiedSetbackMaxAttribute(
         OccupiedSetbackMaxAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOccupiedSetbackMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OCCUPIED_SETBACK_MAX_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OCCUPIED_SETBACK_MAX_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUnoccupiedSetbackAttribute(
         UnoccupiedSetbackAttributeCallback callback) {
-        readUnoccupiedSetbackAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNOCCUPIED_SETBACK_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UNOCCUPIED_SETBACK_ATTRIBUTE_ID, true);
     }
 
     public void writeUnoccupiedSetbackAttribute(DefaultClusterCallback callback, Integer value) {
-        writeUnoccupiedSetbackAttribute(chipClusterPtr, callback, value, null);
+      writeUnoccupiedSetbackAttribute(callback, value, 0);
     }
 
     public void writeUnoccupiedSetbackAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeUnoccupiedSetbackAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), UNOCCUPIED_SETBACK_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeUnoccupiedSetbackAttribute(
         UnoccupiedSetbackAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUnoccupiedSetbackAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNOCCUPIED_SETBACK_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UNOCCUPIED_SETBACK_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUnoccupiedSetbackMinAttribute(
         UnoccupiedSetbackMinAttributeCallback callback) {
-        readUnoccupiedSetbackMinAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNOCCUPIED_SETBACK_MIN_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UNOCCUPIED_SETBACK_MIN_ATTRIBUTE_ID, true);
     }
 
     public void subscribeUnoccupiedSetbackMinAttribute(
         UnoccupiedSetbackMinAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUnoccupiedSetbackMinAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNOCCUPIED_SETBACK_MIN_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UNOCCUPIED_SETBACK_MIN_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUnoccupiedSetbackMaxAttribute(
         UnoccupiedSetbackMaxAttributeCallback callback) {
-        readUnoccupiedSetbackMaxAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNOCCUPIED_SETBACK_MAX_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UNOCCUPIED_SETBACK_MAX_ATTRIBUTE_ID, true);
     }
 
     public void subscribeUnoccupiedSetbackMaxAttribute(
         UnoccupiedSetbackMaxAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUnoccupiedSetbackMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNOCCUPIED_SETBACK_MAX_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UNOCCUPIED_SETBACK_MAX_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEmergencyHeatDeltaAttribute(
         IntegerAttributeCallback callback) {
-        readEmergencyHeatDeltaAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EMERGENCY_HEAT_DELTA_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EMERGENCY_HEAT_DELTA_ATTRIBUTE_ID, true);
     }
 
     public void writeEmergencyHeatDeltaAttribute(DefaultClusterCallback callback, Integer value) {
-        writeEmergencyHeatDeltaAttribute(chipClusterPtr, callback, value, null);
+      writeEmergencyHeatDeltaAttribute(callback, value, 0);
     }
 
     public void writeEmergencyHeatDeltaAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeEmergencyHeatDeltaAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), EMERGENCY_HEAT_DELTA_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeEmergencyHeatDeltaAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEmergencyHeatDeltaAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EMERGENCY_HEAT_DELTA_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EMERGENCY_HEAT_DELTA_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readACTypeAttribute(
         IntegerAttributeCallback callback) {
-        readACTypeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, A_C_TYPE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, A_C_TYPE_ATTRIBUTE_ID, true);
     }
 
     public void writeACTypeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeACTypeAttribute(chipClusterPtr, callback, value, null);
+      writeACTypeAttribute(callback, value, 0);
     }
 
     public void writeACTypeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeACTypeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), A_C_TYPE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeACTypeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeACTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, A_C_TYPE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, A_C_TYPE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readACCapacityAttribute(
         IntegerAttributeCallback callback) {
-        readACCapacityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, A_C_CAPACITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, A_C_CAPACITY_ATTRIBUTE_ID, true);
     }
 
     public void writeACCapacityAttribute(DefaultClusterCallback callback, Integer value) {
-        writeACCapacityAttribute(chipClusterPtr, callback, value, null);
+      writeACCapacityAttribute(callback, value, 0);
     }
 
     public void writeACCapacityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeACCapacityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), A_C_CAPACITY_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeACCapacityAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeACCapacityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, A_C_CAPACITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, A_C_CAPACITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readACRefrigerantTypeAttribute(
         IntegerAttributeCallback callback) {
-        readACRefrigerantTypeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, A_C_REFRIGERANT_TYPE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, A_C_REFRIGERANT_TYPE_ATTRIBUTE_ID, true);
     }
 
     public void writeACRefrigerantTypeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeACRefrigerantTypeAttribute(chipClusterPtr, callback, value, null);
+      writeACRefrigerantTypeAttribute(callback, value, 0);
     }
 
     public void writeACRefrigerantTypeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeACRefrigerantTypeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), A_C_REFRIGERANT_TYPE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeACRefrigerantTypeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeACRefrigerantTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, A_C_REFRIGERANT_TYPE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, A_C_REFRIGERANT_TYPE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readACCompressorTypeAttribute(
         IntegerAttributeCallback callback) {
-        readACCompressorTypeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, A_C_COMPRESSOR_TYPE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, A_C_COMPRESSOR_TYPE_ATTRIBUTE_ID, true);
     }
 
     public void writeACCompressorTypeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeACCompressorTypeAttribute(chipClusterPtr, callback, value, null);
+      writeACCompressorTypeAttribute(callback, value, 0);
     }
 
     public void writeACCompressorTypeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeACCompressorTypeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), A_C_COMPRESSOR_TYPE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeACCompressorTypeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeACCompressorTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, A_C_COMPRESSOR_TYPE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, A_C_COMPRESSOR_TYPE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readACErrorCodeAttribute(
         LongAttributeCallback callback) {
-        readACErrorCodeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, A_C_ERROR_CODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, A_C_ERROR_CODE_ATTRIBUTE_ID, true);
     }
 
     public void writeACErrorCodeAttribute(DefaultClusterCallback callback, Long value) {
-        writeACErrorCodeAttribute(chipClusterPtr, callback, value, null);
+      writeACErrorCodeAttribute(callback, value, 0);
     }
 
     public void writeACErrorCodeAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeACErrorCodeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), A_C_ERROR_CODE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeACErrorCodeAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeACErrorCodeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, A_C_ERROR_CODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, A_C_ERROR_CODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readACLouverPositionAttribute(
         IntegerAttributeCallback callback) {
-        readACLouverPositionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, A_C_LOUVER_POSITION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, A_C_LOUVER_POSITION_ATTRIBUTE_ID, true);
     }
 
     public void writeACLouverPositionAttribute(DefaultClusterCallback callback, Integer value) {
-        writeACLouverPositionAttribute(chipClusterPtr, callback, value, null);
+      writeACLouverPositionAttribute(callback, value, 0);
     }
 
     public void writeACLouverPositionAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeACLouverPositionAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), A_C_LOUVER_POSITION_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeACLouverPositionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeACLouverPositionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, A_C_LOUVER_POSITION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, A_C_LOUVER_POSITION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readACCoilTemperatureAttribute(
         ACCoilTemperatureAttributeCallback callback) {
-        readACCoilTemperatureAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, A_C_COIL_TEMPERATURE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, A_C_COIL_TEMPERATURE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeACCoilTemperatureAttribute(
         ACCoilTemperatureAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeACCoilTemperatureAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, A_C_COIL_TEMPERATURE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, A_C_COIL_TEMPERATURE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readACCapacityformatAttribute(
         IntegerAttributeCallback callback) {
-        readACCapacityformatAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, A_C_CAPACITYFORMAT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, A_C_CAPACITYFORMAT_ATTRIBUTE_ID, true);
     }
 
     public void writeACCapacityformatAttribute(DefaultClusterCallback callback, Integer value) {
-        writeACCapacityformatAttribute(chipClusterPtr, callback, value, null);
+      writeACCapacityformatAttribute(callback, value, 0);
     }
 
     public void writeACCapacityformatAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeACCapacityformatAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), A_C_CAPACITYFORMAT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeACCapacityformatAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeACCapacityformatAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, A_C_CAPACITYFORMAT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, A_C_CAPACITYFORMAT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readLocalTemperatureAttribute(long chipClusterPtr, LocalTemperatureAttributeCallback callback);
-
-    private native void subscribeLocalTemperatureAttribute(long chipClusterPtr, LocalTemperatureAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readOutdoorTemperatureAttribute(long chipClusterPtr, OutdoorTemperatureAttributeCallback callback);
-
-    private native void subscribeOutdoorTemperatureAttribute(long chipClusterPtr, OutdoorTemperatureAttributeCallback 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 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 readPICoolingDemandAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribePICoolingDemandAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPIHeatingDemandAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribePIHeatingDemandAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readHVACSystemTypeConfigurationAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeHVACSystemTypeConfigurationAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeHVACSystemTypeConfigurationAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLocalTemperatureCalibrationAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeLocalTemperatureCalibrationAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeLocalTemperatureCalibrationAttribute(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 readUnoccupiedCoolingSetpointAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeUnoccupiedCoolingSetpointAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeUnoccupiedCoolingSetpointAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readUnoccupiedHeatingSetpointAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeUnoccupiedHeatingSetpointAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeUnoccupiedHeatingSetpointAttribute(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 readRemoteSensingAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeRemoteSensingAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeRemoteSensingAttribute(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 readThermostatRunningModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeThermostatRunningModeAttribute(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 readTemperatureSetpointHoldAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeTemperatureSetpointHoldAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeTemperatureSetpointHoldAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readTemperatureSetpointHoldDurationAttribute(long chipClusterPtr, TemperatureSetpointHoldDurationAttributeCallback callback);
-
-    private native void writeTemperatureSetpointHoldDurationAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeTemperatureSetpointHoldDurationAttribute(long chipClusterPtr, TemperatureSetpointHoldDurationAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readThermostatProgrammingOperationModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeThermostatProgrammingOperationModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeThermostatProgrammingOperationModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readThermostatRunningStateAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeThermostatRunningStateAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSetpointChangeSourceAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeSetpointChangeSourceAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSetpointChangeAmountAttribute(long chipClusterPtr, SetpointChangeAmountAttributeCallback callback);
-
-    private native void subscribeSetpointChangeAmountAttribute(long chipClusterPtr, SetpointChangeAmountAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSetpointChangeSourceTimestampAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeSetpointChangeSourceTimestampAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readOccupiedSetbackAttribute(long chipClusterPtr, OccupiedSetbackAttributeCallback callback);
-
-    private native void writeOccupiedSetbackAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeOccupiedSetbackAttribute(long chipClusterPtr, OccupiedSetbackAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readOccupiedSetbackMinAttribute(long chipClusterPtr, OccupiedSetbackMinAttributeCallback callback);
-
-    private native void subscribeOccupiedSetbackMinAttribute(long chipClusterPtr, OccupiedSetbackMinAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readOccupiedSetbackMaxAttribute(long chipClusterPtr, OccupiedSetbackMaxAttributeCallback callback);
-
-    private native void subscribeOccupiedSetbackMaxAttribute(long chipClusterPtr, OccupiedSetbackMaxAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readUnoccupiedSetbackAttribute(long chipClusterPtr, UnoccupiedSetbackAttributeCallback callback);
-
-    private native void writeUnoccupiedSetbackAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeUnoccupiedSetbackAttribute(long chipClusterPtr, UnoccupiedSetbackAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readUnoccupiedSetbackMinAttribute(long chipClusterPtr, UnoccupiedSetbackMinAttributeCallback callback);
-
-    private native void subscribeUnoccupiedSetbackMinAttribute(long chipClusterPtr, UnoccupiedSetbackMinAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readUnoccupiedSetbackMaxAttribute(long chipClusterPtr, UnoccupiedSetbackMaxAttributeCallback callback);
-
-    private native void subscribeUnoccupiedSetbackMaxAttribute(long chipClusterPtr, UnoccupiedSetbackMaxAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEmergencyHeatDeltaAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeEmergencyHeatDeltaAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeEmergencyHeatDeltaAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readACTypeAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeACTypeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeACTypeAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readACCapacityAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeACCapacityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeACCapacityAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readACRefrigerantTypeAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeACRefrigerantTypeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeACRefrigerantTypeAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readACCompressorTypeAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeACCompressorTypeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeACCompressorTypeAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readACErrorCodeAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void writeACErrorCodeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeACErrorCodeAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readACLouverPositionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeACLouverPositionAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeACLouverPositionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readACCoilTemperatureAttribute(long chipClusterPtr, ACCoilTemperatureAttributeCallback callback);
-
-    private native void subscribeACCoilTemperatureAttribute(long chipClusterPtr, ACCoilTemperatureAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readACCapacityformatAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeACCapacityformatAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeACCapacityformatAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class FanControlCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 514L;
 
+    private static final long FAN_MODE_ATTRIBUTE_ID = 0L;
+    private static final long FAN_MODE_SEQUENCE_ATTRIBUTE_ID = 1L;
+    private static final long PERCENT_SETTING_ATTRIBUTE_ID = 2L;
+    private static final long PERCENT_CURRENT_ATTRIBUTE_ID = 3L;
+    private static final long SPEED_MAX_ATTRIBUTE_ID = 4L;
+    private static final long SPEED_SETTING_ATTRIBUTE_ID = 5L;
+    private static final long SPEED_CURRENT_ATTRIBUTE_ID = 6L;
+    private static final long ROCK_SUPPORT_ATTRIBUTE_ID = 7L;
+    private static final long ROCK_SETTING_ATTRIBUTE_ID = 8L;
+    private static final long WIND_SUPPORT_ATTRIBUTE_ID = 9L;
+    private static final long WIND_SETTING_ATTRIBUTE_ID = 10L;
+    private static final long AIRFLOW_DIRECTION_ATTRIBUTE_ID = 11L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public FanControlCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void step(DefaultClusterCallback callback, Integer direction, Optional<Boolean> wrap, Optional<Boolean> lowestOff) {
-      step(chipClusterPtr, callback, direction, wrap, lowestOff, null);
+      step(callback, direction, wrap, lowestOff, 0);
     }
 
     public void step(DefaultClusterCallback callback, Integer direction, Optional<Boolean> wrap, Optional<Boolean> lowestOff, int timedInvokeTimeoutMs) {
-      step(chipClusterPtr, callback, direction, wrap, lowestOff, timedInvokeTimeoutMs);
-    }
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long directionFieldID = 0L;
+      BaseTLVType directiontlvValue = new UIntType(direction);
+      elements.add(new StructElement(directionFieldID, directiontlvValue));
+
+      final long wrapFieldID = 1L;
+      BaseTLVType wraptlvValue = wrap.<BaseTLVType>map((nonOptionalwrap) -> new BooleanType(nonOptionalwrap)).orElse(new EmptyType());
+      elements.add(new StructElement(wrapFieldID, wraptlvValue));
 
-    private native void step(long chipClusterPtr, DefaultClusterCallback callback, Integer direction, Optional<Boolean> wrap, Optional<Boolean> lowestOff, @Nullable Integer timedInvokeTimeoutMs);
+      final long lowestOffFieldID = 2L;
+      BaseTLVType lowestOfftlvValue = lowestOff.<BaseTLVType>map((nonOptionallowestOff) -> new BooleanType(nonOptionallowestOff)).orElse(new EmptyType());
+      elements.add(new StructElement(lowestOffFieldID, lowestOfftlvValue));
 
-    public interface PercentSettingAttributeCallback {
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface PercentSettingAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface SpeedSettingAttributeCallback {
+    public interface SpeedSettingAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readFanModeAttribute(
         IntegerAttributeCallback callback) {
-        readFanModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FAN_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FAN_MODE_ATTRIBUTE_ID, true);
     }
 
     public void writeFanModeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeFanModeAttribute(chipClusterPtr, callback, value, null);
+      writeFanModeAttribute(callback, value, 0);
     }
 
     public void writeFanModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeFanModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), FAN_MODE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeFanModeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFanModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FAN_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FAN_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFanModeSequenceAttribute(
         IntegerAttributeCallback callback) {
-        readFanModeSequenceAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FAN_MODE_SEQUENCE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FAN_MODE_SEQUENCE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFanModeSequenceAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFanModeSequenceAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FAN_MODE_SEQUENCE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FAN_MODE_SEQUENCE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPercentSettingAttribute(
         PercentSettingAttributeCallback callback) {
-        readPercentSettingAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PERCENT_SETTING_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PERCENT_SETTING_ATTRIBUTE_ID, true);
     }
 
     public void writePercentSettingAttribute(DefaultClusterCallback callback, Integer value) {
-        writePercentSettingAttribute(chipClusterPtr, callback, value, null);
+      writePercentSettingAttribute(callback, value, 0);
     }
 
     public void writePercentSettingAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writePercentSettingAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), PERCENT_SETTING_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribePercentSettingAttribute(
         PercentSettingAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePercentSettingAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PERCENT_SETTING_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PERCENT_SETTING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPercentCurrentAttribute(
         IntegerAttributeCallback callback) {
-        readPercentCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PERCENT_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PERCENT_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribePercentCurrentAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePercentCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PERCENT_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PERCENT_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSpeedMaxAttribute(
         IntegerAttributeCallback callback) {
-        readSpeedMaxAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SPEED_MAX_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SPEED_MAX_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSpeedMaxAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSpeedMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SPEED_MAX_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SPEED_MAX_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSpeedSettingAttribute(
         SpeedSettingAttributeCallback callback) {
-        readSpeedSettingAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SPEED_SETTING_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SPEED_SETTING_ATTRIBUTE_ID, true);
     }
 
     public void writeSpeedSettingAttribute(DefaultClusterCallback callback, Integer value) {
-        writeSpeedSettingAttribute(chipClusterPtr, callback, value, null);
+      writeSpeedSettingAttribute(callback, value, 0);
     }
 
     public void writeSpeedSettingAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeSpeedSettingAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), SPEED_SETTING_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeSpeedSettingAttribute(
         SpeedSettingAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSpeedSettingAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SPEED_SETTING_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SPEED_SETTING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSpeedCurrentAttribute(
         IntegerAttributeCallback callback) {
-        readSpeedCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SPEED_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SPEED_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSpeedCurrentAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSpeedCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SPEED_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SPEED_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRockSupportAttribute(
         IntegerAttributeCallback callback) {
-        readRockSupportAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ROCK_SUPPORT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ROCK_SUPPORT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRockSupportAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRockSupportAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ROCK_SUPPORT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ROCK_SUPPORT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRockSettingAttribute(
         IntegerAttributeCallback callback) {
-        readRockSettingAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ROCK_SETTING_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ROCK_SETTING_ATTRIBUTE_ID, true);
     }
 
     public void writeRockSettingAttribute(DefaultClusterCallback callback, Integer value) {
-        writeRockSettingAttribute(chipClusterPtr, callback, value, null);
+      writeRockSettingAttribute(callback, value, 0);
     }
 
     public void writeRockSettingAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeRockSettingAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ROCK_SETTING_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeRockSettingAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRockSettingAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ROCK_SETTING_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ROCK_SETTING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readWindSupportAttribute(
         IntegerAttributeCallback callback) {
-        readWindSupportAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WIND_SUPPORT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, WIND_SUPPORT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeWindSupportAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeWindSupportAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WIND_SUPPORT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, WIND_SUPPORT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readWindSettingAttribute(
         IntegerAttributeCallback callback) {
-        readWindSettingAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WIND_SETTING_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, WIND_SETTING_ATTRIBUTE_ID, true);
     }
 
     public void writeWindSettingAttribute(DefaultClusterCallback callback, Integer value) {
-        writeWindSettingAttribute(chipClusterPtr, callback, value, null);
+      writeWindSettingAttribute(callback, value, 0);
     }
 
     public void writeWindSettingAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeWindSettingAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), WIND_SETTING_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeWindSettingAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeWindSettingAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WIND_SETTING_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, WIND_SETTING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAirflowDirectionAttribute(
         IntegerAttributeCallback callback) {
-        readAirflowDirectionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AIRFLOW_DIRECTION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AIRFLOW_DIRECTION_ATTRIBUTE_ID, true);
     }
 
     public void writeAirflowDirectionAttribute(DefaultClusterCallback callback, Integer value) {
-        writeAirflowDirectionAttribute(chipClusterPtr, callback, value, null);
+      writeAirflowDirectionAttribute(callback, value, 0);
     }
 
     public void writeAirflowDirectionAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeAirflowDirectionAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), AIRFLOW_DIRECTION_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeAirflowDirectionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAirflowDirectionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AIRFLOW_DIRECTION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AIRFLOW_DIRECTION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
+  }
 
-    private native void readFanModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+  public static class ThermostatUserInterfaceConfigurationCluster extends BaseChipCluster {
+    public static final long CLUSTER_ID = 516L;
 
-    private native void writeFanModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    private static final long TEMPERATURE_DISPLAY_MODE_ATTRIBUTE_ID = 0L;
+    private static final long KEYPAD_LOCKOUT_ATTRIBUTE_ID = 1L;
+    private static final long SCHEDULE_PROGRAMMING_VISIBILITY_ATTRIBUTE_ID = 2L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
 
-    private native void subscribeFanModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public ThermostatUserInterfaceConfigurationCluster(long devicePtr, int endpointId) {
+      super(devicePtr, endpointId, CLUSTER_ID);
+    }
 
-    private native void readFanModeSequenceAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    @Override
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    private native void subscribeFanModeSequenceAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void readPercentSettingAttribute(long chipClusterPtr, PercentSettingAttributeCallback callback);
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void writePercentSettingAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void subscribePercentSettingAttribute(long chipClusterPtr, PercentSettingAttributeCallback callback, int minInterval, int maxInterval);
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void readPercentCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void readTemperatureDisplayModeAttribute(
+        IntegerAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TEMPERATURE_DISPLAY_MODE_ATTRIBUTE_ID);
 
-    private native void subscribePercentCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TEMPERATURE_DISPLAY_MODE_ATTRIBUTE_ID, true);
+    }
 
-    private native void readSpeedMaxAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void writeTemperatureDisplayModeAttribute(DefaultClusterCallback callback, Integer value) {
+      writeTemperatureDisplayModeAttribute(callback, value, 0);
+    }
 
-    private native void subscribeSpeedMaxAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSpeedSettingAttribute(long chipClusterPtr, SpeedSettingAttributeCallback callback);
-
-    private native void writeSpeedSettingAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeSpeedSettingAttribute(long chipClusterPtr, SpeedSettingAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSpeedCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeSpeedCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRockSupportAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRockSupportAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRockSettingAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeRockSettingAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeRockSettingAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readWindSupportAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeWindSupportAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readWindSettingAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeWindSettingAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeWindSettingAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAirflowDirectionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeAirflowDirectionAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeAirflowDirectionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-  }
-
-  public static class ThermostatUserInterfaceConfigurationCluster extends BaseChipCluster {
-    public static final long CLUSTER_ID = 516L;
-
-    public ThermostatUserInterfaceConfigurationCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
-    }
-
-    @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
-
-    public interface GeneratedCommandListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface AcceptedCommandListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface EventListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface AttributeListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public void readTemperatureDisplayModeAttribute(
-        IntegerAttributeCallback callback) {
-        readTemperatureDisplayModeAttribute(chipClusterPtr, callback);
-    }
-
-    public void writeTemperatureDisplayModeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeTemperatureDisplayModeAttribute(chipClusterPtr, callback, value, null);
-    }
-
-    public void writeTemperatureDisplayModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeTemperatureDisplayModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
+    public void writeTemperatureDisplayModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), TEMPERATURE_DISPLAY_MODE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
     public void subscribeTemperatureDisplayModeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTemperatureDisplayModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TEMPERATURE_DISPLAY_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TEMPERATURE_DISPLAY_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readKeypadLockoutAttribute(
         IntegerAttributeCallback callback) {
-        readKeypadLockoutAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, KEYPAD_LOCKOUT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, KEYPAD_LOCKOUT_ATTRIBUTE_ID, true);
     }
 
     public void writeKeypadLockoutAttribute(DefaultClusterCallback callback, Integer value) {
-        writeKeypadLockoutAttribute(chipClusterPtr, callback, value, null);
+      writeKeypadLockoutAttribute(callback, value, 0);
     }
 
     public void writeKeypadLockoutAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeKeypadLockoutAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), KEYPAD_LOCKOUT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeKeypadLockoutAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeKeypadLockoutAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, KEYPAD_LOCKOUT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, KEYPAD_LOCKOUT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readScheduleProgrammingVisibilityAttribute(
         IntegerAttributeCallback callback) {
-        readScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SCHEDULE_PROGRAMMING_VISIBILITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SCHEDULE_PROGRAMMING_VISIBILITY_ATTRIBUTE_ID, true);
     }
 
     public void writeScheduleProgrammingVisibilityAttribute(DefaultClusterCallback callback, Integer value) {
-        writeScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback, value, null);
+      writeScheduleProgrammingVisibilityAttribute(callback, value, 0);
     }
 
     public void writeScheduleProgrammingVisibilityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), SCHEDULE_PROGRAMMING_VISIBILITY_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeScheduleProgrammingVisibilityAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SCHEDULE_PROGRAMMING_VISIBILITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SCHEDULE_PROGRAMMING_VISIBILITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     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);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeTemperatureDisplayModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
+  }
 
-    private native void readKeypadLockoutAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+  public static class ColorControlCluster extends BaseChipCluster {
+    public static final long CLUSTER_ID = 768L;
 
-    private native void writeKeypadLockoutAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    private static final long CURRENT_HUE_ATTRIBUTE_ID = 0L;
+    private static final long CURRENT_SATURATION_ATTRIBUTE_ID = 1L;
+    private static final long REMAINING_TIME_ATTRIBUTE_ID = 2L;
+    private static final long CURRENT_X_ATTRIBUTE_ID = 3L;
+    private static final long CURRENT_Y_ATTRIBUTE_ID = 4L;
+    private static final long DRIFT_COMPENSATION_ATTRIBUTE_ID = 5L;
+    private static final long COMPENSATION_TEXT_ATTRIBUTE_ID = 6L;
+    private static final long COLOR_TEMPERATURE_MIREDS_ATTRIBUTE_ID = 7L;
+    private static final long COLOR_MODE_ATTRIBUTE_ID = 8L;
+    private static final long OPTIONS_ATTRIBUTE_ID = 15L;
+    private static final long NUMBER_OF_PRIMARIES_ATTRIBUTE_ID = 16L;
+    private static final long PRIMARY1_X_ATTRIBUTE_ID = 17L;
+    private static final long PRIMARY1_Y_ATTRIBUTE_ID = 18L;
+    private static final long PRIMARY1_INTENSITY_ATTRIBUTE_ID = 19L;
+    private static final long PRIMARY2_X_ATTRIBUTE_ID = 21L;
+    private static final long PRIMARY2_Y_ATTRIBUTE_ID = 22L;
+    private static final long PRIMARY2_INTENSITY_ATTRIBUTE_ID = 23L;
+    private static final long PRIMARY3_X_ATTRIBUTE_ID = 25L;
+    private static final long PRIMARY3_Y_ATTRIBUTE_ID = 26L;
+    private static final long PRIMARY3_INTENSITY_ATTRIBUTE_ID = 27L;
+    private static final long PRIMARY4_X_ATTRIBUTE_ID = 32L;
+    private static final long PRIMARY4_Y_ATTRIBUTE_ID = 33L;
+    private static final long PRIMARY4_INTENSITY_ATTRIBUTE_ID = 34L;
+    private static final long PRIMARY5_X_ATTRIBUTE_ID = 36L;
+    private static final long PRIMARY5_Y_ATTRIBUTE_ID = 37L;
+    private static final long PRIMARY5_INTENSITY_ATTRIBUTE_ID = 38L;
+    private static final long PRIMARY6_X_ATTRIBUTE_ID = 40L;
+    private static final long PRIMARY6_Y_ATTRIBUTE_ID = 41L;
+    private static final long PRIMARY6_INTENSITY_ATTRIBUTE_ID = 42L;
+    private static final long WHITE_POINT_X_ATTRIBUTE_ID = 48L;
+    private static final long WHITE_POINT_Y_ATTRIBUTE_ID = 49L;
+    private static final long COLOR_POINT_R_X_ATTRIBUTE_ID = 50L;
+    private static final long COLOR_POINT_R_Y_ATTRIBUTE_ID = 51L;
+    private static final long COLOR_POINT_R_INTENSITY_ATTRIBUTE_ID = 52L;
+    private static final long COLOR_POINT_G_X_ATTRIBUTE_ID = 54L;
+    private static final long COLOR_POINT_G_Y_ATTRIBUTE_ID = 55L;
+    private static final long COLOR_POINT_G_INTENSITY_ATTRIBUTE_ID = 56L;
+    private static final long COLOR_POINT_B_X_ATTRIBUTE_ID = 58L;
+    private static final long COLOR_POINT_B_Y_ATTRIBUTE_ID = 59L;
+    private static final long COLOR_POINT_B_INTENSITY_ATTRIBUTE_ID = 60L;
+    private static final long ENHANCED_CURRENT_HUE_ATTRIBUTE_ID = 16384L;
+    private static final long ENHANCED_COLOR_MODE_ATTRIBUTE_ID = 16385L;
+    private static final long COLOR_LOOP_ACTIVE_ATTRIBUTE_ID = 16386L;
+    private static final long COLOR_LOOP_DIRECTION_ATTRIBUTE_ID = 16387L;
+    private static final long COLOR_LOOP_TIME_ATTRIBUTE_ID = 16388L;
+    private static final long COLOR_LOOP_START_ENHANCED_HUE_ATTRIBUTE_ID = 16389L;
+    private static final long COLOR_LOOP_STORED_ENHANCED_HUE_ATTRIBUTE_ID = 16390L;
+    private static final long COLOR_CAPABILITIES_ATTRIBUTE_ID = 16394L;
+    private static final long COLOR_TEMP_PHYSICAL_MIN_MIREDS_ATTRIBUTE_ID = 16395L;
+    private static final long COLOR_TEMP_PHYSICAL_MAX_MIREDS_ATTRIBUTE_ID = 16396L;
+    private static final long COUPLE_COLOR_TEMP_TO_LEVEL_MIN_MIREDS_ATTRIBUTE_ID = 16397L;
+    private static final long START_UP_COLOR_TEMPERATURE_MIREDS_ATTRIBUTE_ID = 16400L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
 
-    private native void subscribeKeypadLockoutAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public ColorControlCluster(long devicePtr, int endpointId) {
+      super(devicePtr, endpointId, CLUSTER_ID);
+    }
 
-    private native void readScheduleProgrammingVisibilityAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    @Override
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    private native void writeScheduleProgrammingVisibilityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    public void moveToHue(DefaultClusterCallback callback, Integer hue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride) {
+      moveToHue(callback, hue, direction, transitionTime, optionsMask, optionsOverride, 0);
+    }
 
-    private native void subscribeScheduleProgrammingVisibilityAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void moveToHue(DefaultClusterCallback callback, Integer hue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
+      final long commandId = 0L;
 
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long hueFieldID = 0L;
+      BaseTLVType huetlvValue = new UIntType(hue);
+      elements.add(new StructElement(hueFieldID, huetlvValue));
 
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      final long directionFieldID = 1L;
+      BaseTLVType directiontlvValue = new UIntType(direction);
+      elements.add(new StructElement(directionFieldID, directiontlvValue));
 
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
+      final long transitionTimeFieldID = 2L;
+      BaseTLVType transitionTimetlvValue = new UIntType(transitionTime);
+      elements.add(new StructElement(transitionTimeFieldID, transitionTimetlvValue));
 
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      final long optionsMaskFieldID = 3L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
 
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
+      final long optionsOverrideFieldID = 4L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
 
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
+    public void moveHue(DefaultClusterCallback callback, Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) {
+      moveHue(callback, moveMode, rate, optionsMask, optionsOverride, 0);
+    }
 
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
+    public void moveHue(DefaultClusterCallback callback, Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
+      final long commandId = 1L;
 
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long moveModeFieldID = 0L;
+      BaseTLVType moveModetlvValue = new UIntType(moveMode);
+      elements.add(new StructElement(moveModeFieldID, moveModetlvValue));
 
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+      final long rateFieldID = 1L;
+      BaseTLVType ratetlvValue = new UIntType(rate);
+      elements.add(new StructElement(rateFieldID, ratetlvValue));
 
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+      final long optionsMaskFieldID = 2L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
 
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-  }
+      final long optionsOverrideFieldID = 3L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
 
-  public static class ColorControlCluster extends BaseChipCluster {
-    public static final long CLUSTER_ID = 768L;
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public ColorControlCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+    public void stepHue(DefaultClusterCallback callback, Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride) {
+      stepHue(callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, 0);
     }
 
-    @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    public void stepHue(DefaultClusterCallback callback, Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
+      final long commandId = 2L;
 
-    public void moveToHue(DefaultClusterCallback callback, Integer hue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride) {
-      moveToHue(chipClusterPtr, callback, hue, direction, transitionTime, optionsMask, optionsOverride, null);
-    }
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long stepModeFieldID = 0L;
+      BaseTLVType stepModetlvValue = new UIntType(stepMode);
+      elements.add(new StructElement(stepModeFieldID, stepModetlvValue));
 
-    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);
-    }
+      final long stepSizeFieldID = 1L;
+      BaseTLVType stepSizetlvValue = new UIntType(stepSize);
+      elements.add(new StructElement(stepSizeFieldID, stepSizetlvValue));
 
-    public void moveHue(DefaultClusterCallback callback, Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) {
-      moveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null);
-    }
+      final long transitionTimeFieldID = 2L;
+      BaseTLVType transitionTimetlvValue = new UIntType(transitionTime);
+      elements.add(new StructElement(transitionTimeFieldID, transitionTimetlvValue));
 
-    public void moveHue(DefaultClusterCallback callback, Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
-      moveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs);
-    }
+      final long optionsMaskFieldID = 3L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
 
-    public void stepHue(DefaultClusterCallback callback, Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride) {
-      stepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null);
-    }
+      final long optionsOverrideFieldID = 4L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
 
-    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);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void moveToSaturation(DefaultClusterCallback callback, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride) {
-      moveToSaturation(chipClusterPtr, callback, saturation, transitionTime, optionsMask, optionsOverride, null);
+      moveToSaturation(callback, saturation, transitionTime, optionsMask, optionsOverride, 0);
     }
 
     public void moveToSaturation(DefaultClusterCallback callback, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
-      moveToSaturation(chipClusterPtr, callback, saturation, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs);
+      final long commandId = 3L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long saturationFieldID = 0L;
+      BaseTLVType saturationtlvValue = new UIntType(saturation);
+      elements.add(new StructElement(saturationFieldID, saturationtlvValue));
+
+      final long transitionTimeFieldID = 1L;
+      BaseTLVType transitionTimetlvValue = new UIntType(transitionTime);
+      elements.add(new StructElement(transitionTimeFieldID, transitionTimetlvValue));
+
+      final long optionsMaskFieldID = 2L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
+
+      final long optionsOverrideFieldID = 3L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void moveSaturation(DefaultClusterCallback callback, Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) {
-      moveSaturation(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null);
+      moveSaturation(callback, moveMode, rate, optionsMask, optionsOverride, 0);
     }
 
     public void moveSaturation(DefaultClusterCallback callback, Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
-      moveSaturation(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs);
+      final long commandId = 4L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long moveModeFieldID = 0L;
+      BaseTLVType moveModetlvValue = new UIntType(moveMode);
+      elements.add(new StructElement(moveModeFieldID, moveModetlvValue));
+
+      final long rateFieldID = 1L;
+      BaseTLVType ratetlvValue = new UIntType(rate);
+      elements.add(new StructElement(rateFieldID, ratetlvValue));
+
+      final long optionsMaskFieldID = 2L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
+
+      final long optionsOverrideFieldID = 3L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, 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);
+      stepSaturation(callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, 0);
     }
 
     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);
+      final long commandId = 5L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long stepModeFieldID = 0L;
+      BaseTLVType stepModetlvValue = new UIntType(stepMode);
+      elements.add(new StructElement(stepModeFieldID, stepModetlvValue));
+
+      final long stepSizeFieldID = 1L;
+      BaseTLVType stepSizetlvValue = new UIntType(stepSize);
+      elements.add(new StructElement(stepSizeFieldID, stepSizetlvValue));
+
+      final long transitionTimeFieldID = 2L;
+      BaseTLVType transitionTimetlvValue = new UIntType(transitionTime);
+      elements.add(new StructElement(transitionTimeFieldID, transitionTimetlvValue));
+
+      final long optionsMaskFieldID = 3L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
+
+      final long optionsOverrideFieldID = 4L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, 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);
+      moveToHueAndSaturation(callback, hue, saturation, transitionTime, optionsMask, optionsOverride, 0);
     }
 
     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);
+      final long commandId = 6L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long hueFieldID = 0L;
+      BaseTLVType huetlvValue = new UIntType(hue);
+      elements.add(new StructElement(hueFieldID, huetlvValue));
+
+      final long saturationFieldID = 1L;
+      BaseTLVType saturationtlvValue = new UIntType(saturation);
+      elements.add(new StructElement(saturationFieldID, saturationtlvValue));
+
+      final long transitionTimeFieldID = 2L;
+      BaseTLVType transitionTimetlvValue = new UIntType(transitionTime);
+      elements.add(new StructElement(transitionTimeFieldID, transitionTimetlvValue));
+
+      final long optionsMaskFieldID = 3L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
+
+      final long optionsOverrideFieldID = 4L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, 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);
+      moveToColor(callback, colorX, colorY, transitionTime, optionsMask, optionsOverride, 0);
     }
 
     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);
+      final long commandId = 7L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long colorXFieldID = 0L;
+      BaseTLVType colorXtlvValue = new UIntType(colorX);
+      elements.add(new StructElement(colorXFieldID, colorXtlvValue));
+
+      final long colorYFieldID = 1L;
+      BaseTLVType colorYtlvValue = new UIntType(colorY);
+      elements.add(new StructElement(colorYFieldID, colorYtlvValue));
+
+      final long transitionTimeFieldID = 2L;
+      BaseTLVType transitionTimetlvValue = new UIntType(transitionTime);
+      elements.add(new StructElement(transitionTimeFieldID, transitionTimetlvValue));
+
+      final long optionsMaskFieldID = 3L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
+
+      final long optionsOverrideFieldID = 4L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void moveColor(DefaultClusterCallback callback, Integer rateX, Integer rateY, Integer optionsMask, Integer optionsOverride) {
-      moveColor(chipClusterPtr, callback, rateX, rateY, optionsMask, optionsOverride, null);
+      moveColor(callback, rateX, rateY, optionsMask, optionsOverride, 0);
     }
 
     public void moveColor(DefaultClusterCallback callback, Integer rateX, Integer rateY, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
-      moveColor(chipClusterPtr, callback, rateX, rateY, optionsMask, optionsOverride, timedInvokeTimeoutMs);
+      final long commandId = 8L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long rateXFieldID = 0L;
+      BaseTLVType rateXtlvValue = new IntType(rateX);
+      elements.add(new StructElement(rateXFieldID, rateXtlvValue));
+
+      final long rateYFieldID = 1L;
+      BaseTLVType rateYtlvValue = new IntType(rateY);
+      elements.add(new StructElement(rateYFieldID, rateYtlvValue));
+
+      final long optionsMaskFieldID = 2L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
+
+      final long optionsOverrideFieldID = 3L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, 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);
+      stepColor(callback, stepX, stepY, transitionTime, optionsMask, optionsOverride, 0);
     }
 
     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);
+      final long commandId = 9L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long stepXFieldID = 0L;
+      BaseTLVType stepXtlvValue = new IntType(stepX);
+      elements.add(new StructElement(stepXFieldID, stepXtlvValue));
+
+      final long stepYFieldID = 1L;
+      BaseTLVType stepYtlvValue = new IntType(stepY);
+      elements.add(new StructElement(stepYFieldID, stepYtlvValue));
+
+      final long transitionTimeFieldID = 2L;
+      BaseTLVType transitionTimetlvValue = new UIntType(transitionTime);
+      elements.add(new StructElement(transitionTimeFieldID, transitionTimetlvValue));
+
+      final long optionsMaskFieldID = 3L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
+
+      final long optionsOverrideFieldID = 4L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void moveToColorTemperature(DefaultClusterCallback callback, Integer colorTemperatureMireds, Integer transitionTime, Integer optionsMask, Integer optionsOverride) {
-      moveToColorTemperature(chipClusterPtr, callback, colorTemperatureMireds, transitionTime, optionsMask, optionsOverride, null);
+      moveToColorTemperature(callback, colorTemperatureMireds, transitionTime, optionsMask, optionsOverride, 0);
     }
 
     public void moveToColorTemperature(DefaultClusterCallback callback, Integer colorTemperatureMireds, Integer transitionTime, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
-      moveToColorTemperature(chipClusterPtr, callback, colorTemperatureMireds, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs);
+      final long commandId = 10L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long colorTemperatureMiredsFieldID = 0L;
+      BaseTLVType colorTemperatureMiredstlvValue = new UIntType(colorTemperatureMireds);
+      elements.add(new StructElement(colorTemperatureMiredsFieldID, colorTemperatureMiredstlvValue));
+
+      final long transitionTimeFieldID = 1L;
+      BaseTLVType transitionTimetlvValue = new UIntType(transitionTime);
+      elements.add(new StructElement(transitionTimeFieldID, transitionTimetlvValue));
+
+      final long optionsMaskFieldID = 2L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
+
+      final long optionsOverrideFieldID = 3L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, 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);
+      enhancedMoveToHue(callback, enhancedHue, direction, transitionTime, optionsMask, optionsOverride, 0);
     }
 
     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);
+      final long commandId = 64L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long enhancedHueFieldID = 0L;
+      BaseTLVType enhancedHuetlvValue = new UIntType(enhancedHue);
+      elements.add(new StructElement(enhancedHueFieldID, enhancedHuetlvValue));
+
+      final long directionFieldID = 1L;
+      BaseTLVType directiontlvValue = new UIntType(direction);
+      elements.add(new StructElement(directionFieldID, directiontlvValue));
+
+      final long transitionTimeFieldID = 2L;
+      BaseTLVType transitionTimetlvValue = new UIntType(transitionTime);
+      elements.add(new StructElement(transitionTimeFieldID, transitionTimetlvValue));
+
+      final long optionsMaskFieldID = 3L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
+
+      final long optionsOverrideFieldID = 4L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void enhancedMoveHue(DefaultClusterCallback callback, Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) {
-      enhancedMoveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null);
+      enhancedMoveHue(callback, moveMode, rate, optionsMask, optionsOverride, 0);
     }
 
     public void enhancedMoveHue(DefaultClusterCallback callback, Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
-      enhancedMoveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs);
+      final long commandId = 65L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long moveModeFieldID = 0L;
+      BaseTLVType moveModetlvValue = new UIntType(moveMode);
+      elements.add(new StructElement(moveModeFieldID, moveModetlvValue));
+
+      final long rateFieldID = 1L;
+      BaseTLVType ratetlvValue = new UIntType(rate);
+      elements.add(new StructElement(rateFieldID, ratetlvValue));
+
+      final long optionsMaskFieldID = 2L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
+
+      final long optionsOverrideFieldID = 3L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, 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);
+      enhancedStepHue(callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, 0);
     }
 
     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);
+      final long commandId = 66L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long stepModeFieldID = 0L;
+      BaseTLVType stepModetlvValue = new UIntType(stepMode);
+      elements.add(new StructElement(stepModeFieldID, stepModetlvValue));
+
+      final long stepSizeFieldID = 1L;
+      BaseTLVType stepSizetlvValue = new UIntType(stepSize);
+      elements.add(new StructElement(stepSizeFieldID, stepSizetlvValue));
+
+      final long transitionTimeFieldID = 2L;
+      BaseTLVType transitionTimetlvValue = new UIntType(transitionTime);
+      elements.add(new StructElement(transitionTimeFieldID, transitionTimetlvValue));
+
+      final long optionsMaskFieldID = 3L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
+
+      final long optionsOverrideFieldID = 4L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, 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);
+      enhancedMoveToHueAndSaturation(callback, enhancedHue, saturation, transitionTime, optionsMask, optionsOverride, 0);
     }
 
     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);
+      final long commandId = 67L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long enhancedHueFieldID = 0L;
+      BaseTLVType enhancedHuetlvValue = new UIntType(enhancedHue);
+      elements.add(new StructElement(enhancedHueFieldID, enhancedHuetlvValue));
+
+      final long saturationFieldID = 1L;
+      BaseTLVType saturationtlvValue = new UIntType(saturation);
+      elements.add(new StructElement(saturationFieldID, saturationtlvValue));
+
+      final long transitionTimeFieldID = 2L;
+      BaseTLVType transitionTimetlvValue = new UIntType(transitionTime);
+      elements.add(new StructElement(transitionTimeFieldID, transitionTimetlvValue));
+
+      final long optionsMaskFieldID = 3L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
+
+      final long optionsOverrideFieldID = 4L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     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);
+      colorLoopSet(callback, updateFlags, action, direction, time, startHue, optionsMask, optionsOverride, 0);
     }
 
     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);
+      final long commandId = 68L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long updateFlagsFieldID = 0L;
+      BaseTLVType updateFlagstlvValue = new UIntType(updateFlags);
+      elements.add(new StructElement(updateFlagsFieldID, updateFlagstlvValue));
+
+      final long actionFieldID = 1L;
+      BaseTLVType actiontlvValue = new UIntType(action);
+      elements.add(new StructElement(actionFieldID, actiontlvValue));
+
+      final long directionFieldID = 2L;
+      BaseTLVType directiontlvValue = new UIntType(direction);
+      elements.add(new StructElement(directionFieldID, directiontlvValue));
+
+      final long timeFieldID = 3L;
+      BaseTLVType timetlvValue = new UIntType(time);
+      elements.add(new StructElement(timeFieldID, timetlvValue));
+
+      final long startHueFieldID = 4L;
+      BaseTLVType startHuetlvValue = new UIntType(startHue);
+      elements.add(new StructElement(startHueFieldID, startHuetlvValue));
+
+      final long optionsMaskFieldID = 5L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
+
+      final long optionsOverrideFieldID = 6L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void stopMoveStep(DefaultClusterCallback callback, Integer optionsMask, Integer optionsOverride) {
-      stopMoveStep(chipClusterPtr, callback, optionsMask, optionsOverride, null);
+      stopMoveStep(callback, optionsMask, optionsOverride, 0);
     }
 
     public void stopMoveStep(DefaultClusterCallback callback, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
-      stopMoveStep(chipClusterPtr, callback, optionsMask, optionsOverride, timedInvokeTimeoutMs);
-    }
+      final long commandId = 71L;
 
-    public void moveColorTemperature(DefaultClusterCallback callback, Integer moveMode, Integer rate, Integer colorTemperatureMinimumMireds, Integer colorTemperatureMaximumMireds, Integer optionsMask, Integer optionsOverride) {
-      moveColorTemperature(chipClusterPtr, callback, moveMode, rate, colorTemperatureMinimumMireds, colorTemperatureMaximumMireds, optionsMask, optionsOverride, null);
-    }
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long optionsMaskFieldID = 0L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
 
-    public void moveColorTemperature(DefaultClusterCallback callback, Integer moveMode, Integer rate, Integer colorTemperatureMinimumMireds, Integer colorTemperatureMaximumMireds, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
-      moveColorTemperature(chipClusterPtr, callback, moveMode, rate, colorTemperatureMinimumMireds, colorTemperatureMaximumMireds, optionsMask, optionsOverride, timedInvokeTimeoutMs);
-    }
+      final long optionsOverrideFieldID = 1L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
 
-    public void stepColorTemperature(DefaultClusterCallback callback, Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimumMireds, Integer colorTemperatureMaximumMireds, Integer optionsMask, Integer optionsOverride) {
-      stepColorTemperature(chipClusterPtr, callback, stepMode, stepSize, transitionTime, colorTemperatureMinimumMireds, colorTemperatureMaximumMireds, optionsMask, optionsOverride, null);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
-    public void stepColorTemperature(DefaultClusterCallback callback, Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimumMireds, Integer colorTemperatureMaximumMireds, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
-      stepColorTemperature(chipClusterPtr, callback, stepMode, stepSize, transitionTime, colorTemperatureMinimumMireds, colorTemperatureMaximumMireds, optionsMask, optionsOverride, timedInvokeTimeoutMs);
+    public void moveColorTemperature(DefaultClusterCallback callback, Integer moveMode, Integer rate, Integer colorTemperatureMinimumMireds, Integer colorTemperatureMaximumMireds, Integer optionsMask, Integer optionsOverride) {
+      moveColorTemperature(callback, moveMode, rate, colorTemperatureMinimumMireds, colorTemperatureMaximumMireds, optionsMask, optionsOverride, 0);
     }
 
-    private native void moveToHue(long chipClusterPtr, DefaultClusterCallback callback, Integer hue, Integer direction, Integer transitionTime, 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);
+    public void moveColorTemperature(DefaultClusterCallback callback, Integer moveMode, Integer rate, Integer colorTemperatureMinimumMireds, Integer colorTemperatureMaximumMireds, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
+      final long commandId = 75L;
 
-    private native void stepHue(long chipClusterPtr, DefaultClusterCallback callback, Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long moveModeFieldID = 0L;
+      BaseTLVType moveModetlvValue = new UIntType(moveMode);
+      elements.add(new StructElement(moveModeFieldID, moveModetlvValue));
 
-    private native void moveToSaturation(long chipClusterPtr, DefaultClusterCallback callback, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+      final long rateFieldID = 1L;
+      BaseTLVType ratetlvValue = new UIntType(rate);
+      elements.add(new StructElement(rateFieldID, ratetlvValue));
 
-    private native void moveSaturation(long chipClusterPtr, DefaultClusterCallback callback, Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+      final long colorTemperatureMinimumMiredsFieldID = 2L;
+      BaseTLVType colorTemperatureMinimumMiredstlvValue = new UIntType(colorTemperatureMinimumMireds);
+      elements.add(new StructElement(colorTemperatureMinimumMiredsFieldID, colorTemperatureMinimumMiredstlvValue));
 
-    private native void stepSaturation(long chipClusterPtr, DefaultClusterCallback callback, Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+      final long colorTemperatureMaximumMiredsFieldID = 3L;
+      BaseTLVType colorTemperatureMaximumMiredstlvValue = new UIntType(colorTemperatureMaximumMireds);
+      elements.add(new StructElement(colorTemperatureMaximumMiredsFieldID, colorTemperatureMaximumMiredstlvValue));
 
-    private native void moveToHueAndSaturation(long chipClusterPtr, DefaultClusterCallback callback, Integer hue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+      final long optionsMaskFieldID = 4L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
 
-    private native void moveToColor(long chipClusterPtr, DefaultClusterCallback callback, Integer colorX, Integer colorY, Integer transitionTime, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+      final long optionsOverrideFieldID = 5L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
 
-    private native void moveColor(long chipClusterPtr, DefaultClusterCallback callback, Integer rateX, Integer rateY, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void stepColor(long chipClusterPtr, DefaultClusterCallback callback, Integer stepX, Integer stepY, Integer transitionTime, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+    public void stepColorTemperature(DefaultClusterCallback callback, Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimumMireds, Integer colorTemperatureMaximumMireds, Integer optionsMask, Integer optionsOverride) {
+      stepColorTemperature(callback, stepMode, stepSize, transitionTime, colorTemperatureMinimumMireds, colorTemperatureMaximumMireds, optionsMask, optionsOverride, 0);
+    }
 
-    private native void moveToColorTemperature(long chipClusterPtr, DefaultClusterCallback callback, Integer colorTemperatureMireds, Integer transitionTime, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+    public void stepColorTemperature(DefaultClusterCallback callback, Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimumMireds, Integer colorTemperatureMaximumMireds, Integer optionsMask, Integer optionsOverride, int timedInvokeTimeoutMs) {
+      final long commandId = 76L;
 
-    private native void enhancedMoveToHue(long chipClusterPtr, DefaultClusterCallback callback, Integer enhancedHue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long stepModeFieldID = 0L;
+      BaseTLVType stepModetlvValue = new UIntType(stepMode);
+      elements.add(new StructElement(stepModeFieldID, stepModetlvValue));
 
-    private native void enhancedMoveHue(long chipClusterPtr, DefaultClusterCallback callback, Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+      final long stepSizeFieldID = 1L;
+      BaseTLVType stepSizetlvValue = new UIntType(stepSize);
+      elements.add(new StructElement(stepSizeFieldID, stepSizetlvValue));
 
-    private native void enhancedStepHue(long chipClusterPtr, DefaultClusterCallback callback, Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+      final long transitionTimeFieldID = 2L;
+      BaseTLVType transitionTimetlvValue = new UIntType(transitionTime);
+      elements.add(new StructElement(transitionTimeFieldID, transitionTimetlvValue));
 
-    private native void enhancedMoveToHueAndSaturation(long chipClusterPtr, DefaultClusterCallback callback, Integer enhancedHue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+      final long colorTemperatureMinimumMiredsFieldID = 3L;
+      BaseTLVType colorTemperatureMinimumMiredstlvValue = new UIntType(colorTemperatureMinimumMireds);
+      elements.add(new StructElement(colorTemperatureMinimumMiredsFieldID, colorTemperatureMinimumMiredstlvValue));
 
-    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);
+      final long colorTemperatureMaximumMiredsFieldID = 4L;
+      BaseTLVType colorTemperatureMaximumMiredstlvValue = new UIntType(colorTemperatureMaximumMireds);
+      elements.add(new StructElement(colorTemperatureMaximumMiredsFieldID, colorTemperatureMaximumMiredstlvValue));
 
-    private native void stopMoveStep(long chipClusterPtr, DefaultClusterCallback callback, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+      final long optionsMaskFieldID = 5L;
+      BaseTLVType optionsMasktlvValue = new UIntType(optionsMask);
+      elements.add(new StructElement(optionsMaskFieldID, optionsMasktlvValue));
 
-    private native void moveColorTemperature(long chipClusterPtr, DefaultClusterCallback callback, Integer moveMode, Integer rate, Integer colorTemperatureMinimumMireds, Integer colorTemperatureMaximumMireds, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+      final long optionsOverrideFieldID = 6L;
+      BaseTLVType optionsOverridetlvValue = new UIntType(optionsOverride);
+      elements.add(new StructElement(optionsOverrideFieldID, optionsOverridetlvValue));
 
-    private native void stepColorTemperature(long chipClusterPtr, DefaultClusterCallback callback, Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimumMireds, Integer colorTemperatureMaximumMireds, Integer optionsMask, Integer optionsOverride, @Nullable Integer timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface NumberOfPrimariesAttributeCallback {
+    public interface NumberOfPrimariesAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface Primary1IntensityAttributeCallback {
+    public interface Primary1IntensityAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface Primary2IntensityAttributeCallback {
+    public interface Primary2IntensityAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface Primary3IntensityAttributeCallback {
+    public interface Primary3IntensityAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface Primary4IntensityAttributeCallback {
+    public interface Primary4IntensityAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface Primary5IntensityAttributeCallback {
+    public interface Primary5IntensityAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface Primary6IntensityAttributeCallback {
+    public interface Primary6IntensityAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ColorPointRIntensityAttributeCallback {
+    public interface ColorPointRIntensityAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ColorPointGIntensityAttributeCallback {
+    public interface ColorPointGIntensityAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ColorPointBIntensityAttributeCallback {
+    public interface ColorPointBIntensityAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface StartUpColorTemperatureMiredsAttributeCallback {
+    public interface StartUpColorTemperatureMiredsAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readCurrentHueAttribute(
         IntegerAttributeCallback callback) {
-        readCurrentHueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_HUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_HUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentHueAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentHueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_HUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_HUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentSaturationAttribute(
         IntegerAttributeCallback callback) {
-        readCurrentSaturationAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_SATURATION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_SATURATION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentSaturationAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentSaturationAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_SATURATION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_SATURATION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRemainingTimeAttribute(
         IntegerAttributeCallback callback) {
-        readRemainingTimeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REMAINING_TIME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, REMAINING_TIME_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRemainingTimeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRemainingTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REMAINING_TIME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, REMAINING_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentXAttribute(
         IntegerAttributeCallback callback) {
-        readCurrentXAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_X_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_X_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentXAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentXAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_X_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_X_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentYAttribute(
         IntegerAttributeCallback callback) {
-        readCurrentYAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_Y_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_Y_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentYAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentYAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_Y_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_Y_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDriftCompensationAttribute(
         IntegerAttributeCallback callback) {
-        readDriftCompensationAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DRIFT_COMPENSATION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DRIFT_COMPENSATION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDriftCompensationAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDriftCompensationAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DRIFT_COMPENSATION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DRIFT_COMPENSATION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCompensationTextAttribute(
         CharStringAttributeCallback callback) {
-        readCompensationTextAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COMPENSATION_TEXT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COMPENSATION_TEXT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCompensationTextAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCompensationTextAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COMPENSATION_TEXT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COMPENSATION_TEXT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readColorTemperatureMiredsAttribute(
         IntegerAttributeCallback callback) {
-        readColorTemperatureMiredsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_TEMPERATURE_MIREDS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COLOR_TEMPERATURE_MIREDS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeColorTemperatureMiredsAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeColorTemperatureMiredsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_TEMPERATURE_MIREDS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COLOR_TEMPERATURE_MIREDS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readColorModeAttribute(
         IntegerAttributeCallback callback) {
-        readColorModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COLOR_MODE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeColorModeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeColorModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COLOR_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOptionsAttribute(
         IntegerAttributeCallback callback) {
-        readOptionsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPTIONS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OPTIONS_ATTRIBUTE_ID, true);
     }
 
     public void writeOptionsAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOptionsAttribute(chipClusterPtr, callback, value, null);
+      writeOptionsAttribute(callback, value, 0);
     }
 
     public void writeOptionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOptionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), OPTIONS_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOptionsAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOptionsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OPTIONS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OPTIONS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readNumberOfPrimariesAttribute(
         NumberOfPrimariesAttributeCallback callback) {
-        readNumberOfPrimariesAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_PRIMARIES_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NUMBER_OF_PRIMARIES_ATTRIBUTE_ID, true);
     }
 
     public void subscribeNumberOfPrimariesAttribute(
         NumberOfPrimariesAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNumberOfPrimariesAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_PRIMARIES_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NUMBER_OF_PRIMARIES_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPrimary1XAttribute(
         IntegerAttributeCallback callback) {
-        readPrimary1XAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY1_X_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRIMARY1_X_ATTRIBUTE_ID, true);
     }
 
     public void subscribePrimary1XAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePrimary1XAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY1_X_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRIMARY1_X_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPrimary1YAttribute(
         IntegerAttributeCallback callback) {
-        readPrimary1YAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY1_Y_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRIMARY1_Y_ATTRIBUTE_ID, true);
     }
 
     public void subscribePrimary1YAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePrimary1YAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY1_Y_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRIMARY1_Y_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPrimary1IntensityAttribute(
         Primary1IntensityAttributeCallback callback) {
-        readPrimary1IntensityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY1_INTENSITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRIMARY1_INTENSITY_ATTRIBUTE_ID, true);
     }
 
     public void subscribePrimary1IntensityAttribute(
         Primary1IntensityAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePrimary1IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY1_INTENSITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRIMARY1_INTENSITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPrimary2XAttribute(
         IntegerAttributeCallback callback) {
-        readPrimary2XAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY2_X_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRIMARY2_X_ATTRIBUTE_ID, true);
     }
 
     public void subscribePrimary2XAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePrimary2XAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY2_X_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRIMARY2_X_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPrimary2YAttribute(
         IntegerAttributeCallback callback) {
-        readPrimary2YAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY2_Y_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRIMARY2_Y_ATTRIBUTE_ID, true);
     }
 
     public void subscribePrimary2YAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePrimary2YAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY2_Y_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRIMARY2_Y_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPrimary2IntensityAttribute(
         Primary2IntensityAttributeCallback callback) {
-        readPrimary2IntensityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY2_INTENSITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRIMARY2_INTENSITY_ATTRIBUTE_ID, true);
     }
 
     public void subscribePrimary2IntensityAttribute(
         Primary2IntensityAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePrimary2IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY2_INTENSITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRIMARY2_INTENSITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPrimary3XAttribute(
         IntegerAttributeCallback callback) {
-        readPrimary3XAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY3_X_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRIMARY3_X_ATTRIBUTE_ID, true);
     }
 
     public void subscribePrimary3XAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePrimary3XAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY3_X_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRIMARY3_X_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPrimary3YAttribute(
         IntegerAttributeCallback callback) {
-        readPrimary3YAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY3_Y_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRIMARY3_Y_ATTRIBUTE_ID, true);
     }
 
     public void subscribePrimary3YAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePrimary3YAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY3_Y_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRIMARY3_Y_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPrimary3IntensityAttribute(
         Primary3IntensityAttributeCallback callback) {
-        readPrimary3IntensityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY3_INTENSITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRIMARY3_INTENSITY_ATTRIBUTE_ID, true);
     }
 
     public void subscribePrimary3IntensityAttribute(
         Primary3IntensityAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePrimary3IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY3_INTENSITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRIMARY3_INTENSITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPrimary4XAttribute(
         IntegerAttributeCallback callback) {
-        readPrimary4XAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY4_X_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRIMARY4_X_ATTRIBUTE_ID, true);
     }
 
     public void subscribePrimary4XAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePrimary4XAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY4_X_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRIMARY4_X_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPrimary4YAttribute(
         IntegerAttributeCallback callback) {
-        readPrimary4YAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY4_Y_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRIMARY4_Y_ATTRIBUTE_ID, true);
     }
 
     public void subscribePrimary4YAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePrimary4YAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY4_Y_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRIMARY4_Y_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPrimary4IntensityAttribute(
         Primary4IntensityAttributeCallback callback) {
-        readPrimary4IntensityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY4_INTENSITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRIMARY4_INTENSITY_ATTRIBUTE_ID, true);
     }
 
     public void subscribePrimary4IntensityAttribute(
         Primary4IntensityAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePrimary4IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY4_INTENSITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRIMARY4_INTENSITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPrimary5XAttribute(
         IntegerAttributeCallback callback) {
-        readPrimary5XAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY5_X_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRIMARY5_X_ATTRIBUTE_ID, true);
     }
 
     public void subscribePrimary5XAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePrimary5XAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY5_X_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRIMARY5_X_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPrimary5YAttribute(
         IntegerAttributeCallback callback) {
-        readPrimary5YAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY5_Y_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRIMARY5_Y_ATTRIBUTE_ID, true);
     }
 
     public void subscribePrimary5YAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePrimary5YAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY5_Y_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRIMARY5_Y_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPrimary5IntensityAttribute(
         Primary5IntensityAttributeCallback callback) {
-        readPrimary5IntensityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY5_INTENSITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRIMARY5_INTENSITY_ATTRIBUTE_ID, true);
     }
 
     public void subscribePrimary5IntensityAttribute(
         Primary5IntensityAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePrimary5IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY5_INTENSITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRIMARY5_INTENSITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPrimary6XAttribute(
         IntegerAttributeCallback callback) {
-        readPrimary6XAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY6_X_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRIMARY6_X_ATTRIBUTE_ID, true);
     }
 
     public void subscribePrimary6XAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePrimary6XAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY6_X_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRIMARY6_X_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPrimary6YAttribute(
         IntegerAttributeCallback callback) {
-        readPrimary6YAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY6_Y_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRIMARY6_Y_ATTRIBUTE_ID, true);
     }
 
     public void subscribePrimary6YAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePrimary6YAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY6_Y_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRIMARY6_Y_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPrimary6IntensityAttribute(
         Primary6IntensityAttributeCallback callback) {
-        readPrimary6IntensityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY6_INTENSITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRIMARY6_INTENSITY_ATTRIBUTE_ID, true);
     }
 
     public void subscribePrimary6IntensityAttribute(
         Primary6IntensityAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePrimary6IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRIMARY6_INTENSITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRIMARY6_INTENSITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readWhitePointXAttribute(
         IntegerAttributeCallback callback) {
-        readWhitePointXAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WHITE_POINT_X_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, WHITE_POINT_X_ATTRIBUTE_ID, true);
     }
 
     public void writeWhitePointXAttribute(DefaultClusterCallback callback, Integer value) {
-        writeWhitePointXAttribute(chipClusterPtr, callback, value, null);
+      writeWhitePointXAttribute(callback, value, 0);
     }
 
     public void writeWhitePointXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeWhitePointXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), WHITE_POINT_X_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeWhitePointXAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeWhitePointXAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WHITE_POINT_X_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, WHITE_POINT_X_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readWhitePointYAttribute(
         IntegerAttributeCallback callback) {
-        readWhitePointYAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WHITE_POINT_Y_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, WHITE_POINT_Y_ATTRIBUTE_ID, true);
     }
 
     public void writeWhitePointYAttribute(DefaultClusterCallback callback, Integer value) {
-        writeWhitePointYAttribute(chipClusterPtr, callback, value, null);
+      writeWhitePointYAttribute(callback, value, 0);
     }
 
     public void writeWhitePointYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeWhitePointYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), WHITE_POINT_Y_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeWhitePointYAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeWhitePointYAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WHITE_POINT_Y_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, WHITE_POINT_Y_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readColorPointRXAttribute(
         IntegerAttributeCallback callback) {
-        readColorPointRXAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_POINT_R_X_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COLOR_POINT_R_X_ATTRIBUTE_ID, true);
     }
 
     public void writeColorPointRXAttribute(DefaultClusterCallback callback, Integer value) {
-        writeColorPointRXAttribute(chipClusterPtr, callback, value, null);
+      writeColorPointRXAttribute(callback, value, 0);
     }
 
     public void writeColorPointRXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeColorPointRXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), COLOR_POINT_R_X_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeColorPointRXAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeColorPointRXAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_POINT_R_X_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COLOR_POINT_R_X_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readColorPointRYAttribute(
         IntegerAttributeCallback callback) {
-        readColorPointRYAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_POINT_R_Y_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COLOR_POINT_R_Y_ATTRIBUTE_ID, true);
     }
 
     public void writeColorPointRYAttribute(DefaultClusterCallback callback, Integer value) {
-        writeColorPointRYAttribute(chipClusterPtr, callback, value, null);
+      writeColorPointRYAttribute(callback, value, 0);
     }
 
     public void writeColorPointRYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeColorPointRYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), COLOR_POINT_R_Y_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeColorPointRYAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeColorPointRYAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_POINT_R_Y_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COLOR_POINT_R_Y_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readColorPointRIntensityAttribute(
         ColorPointRIntensityAttributeCallback callback) {
-        readColorPointRIntensityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_POINT_R_INTENSITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COLOR_POINT_R_INTENSITY_ATTRIBUTE_ID, true);
     }
 
     public void writeColorPointRIntensityAttribute(DefaultClusterCallback callback, Integer value) {
-        writeColorPointRIntensityAttribute(chipClusterPtr, callback, value, null);
+      writeColorPointRIntensityAttribute(callback, value, 0);
     }
 
     public void writeColorPointRIntensityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeColorPointRIntensityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), COLOR_POINT_R_INTENSITY_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeColorPointRIntensityAttribute(
         ColorPointRIntensityAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeColorPointRIntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_POINT_R_INTENSITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COLOR_POINT_R_INTENSITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readColorPointGXAttribute(
         IntegerAttributeCallback callback) {
-        readColorPointGXAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_POINT_G_X_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COLOR_POINT_G_X_ATTRIBUTE_ID, true);
     }
 
     public void writeColorPointGXAttribute(DefaultClusterCallback callback, Integer value) {
-        writeColorPointGXAttribute(chipClusterPtr, callback, value, null);
+      writeColorPointGXAttribute(callback, value, 0);
     }
 
     public void writeColorPointGXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeColorPointGXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), COLOR_POINT_G_X_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeColorPointGXAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeColorPointGXAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_POINT_G_X_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COLOR_POINT_G_X_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readColorPointGYAttribute(
         IntegerAttributeCallback callback) {
-        readColorPointGYAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_POINT_G_Y_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COLOR_POINT_G_Y_ATTRIBUTE_ID, true);
     }
 
     public void writeColorPointGYAttribute(DefaultClusterCallback callback, Integer value) {
-        writeColorPointGYAttribute(chipClusterPtr, callback, value, null);
+      writeColorPointGYAttribute(callback, value, 0);
     }
 
     public void writeColorPointGYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeColorPointGYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), COLOR_POINT_G_Y_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeColorPointGYAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeColorPointGYAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_POINT_G_Y_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COLOR_POINT_G_Y_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readColorPointGIntensityAttribute(
         ColorPointGIntensityAttributeCallback callback) {
-        readColorPointGIntensityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_POINT_G_INTENSITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COLOR_POINT_G_INTENSITY_ATTRIBUTE_ID, true);
     }
 
     public void writeColorPointGIntensityAttribute(DefaultClusterCallback callback, Integer value) {
-        writeColorPointGIntensityAttribute(chipClusterPtr, callback, value, null);
+      writeColorPointGIntensityAttribute(callback, value, 0);
     }
 
     public void writeColorPointGIntensityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeColorPointGIntensityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), COLOR_POINT_G_INTENSITY_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeColorPointGIntensityAttribute(
         ColorPointGIntensityAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeColorPointGIntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_POINT_G_INTENSITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COLOR_POINT_G_INTENSITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readColorPointBXAttribute(
         IntegerAttributeCallback callback) {
-        readColorPointBXAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_POINT_B_X_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COLOR_POINT_B_X_ATTRIBUTE_ID, true);
     }
 
     public void writeColorPointBXAttribute(DefaultClusterCallback callback, Integer value) {
-        writeColorPointBXAttribute(chipClusterPtr, callback, value, null);
+      writeColorPointBXAttribute(callback, value, 0);
     }
 
     public void writeColorPointBXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeColorPointBXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), COLOR_POINT_B_X_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeColorPointBXAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeColorPointBXAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_POINT_B_X_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COLOR_POINT_B_X_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readColorPointBYAttribute(
         IntegerAttributeCallback callback) {
-        readColorPointBYAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_POINT_B_Y_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COLOR_POINT_B_Y_ATTRIBUTE_ID, true);
     }
 
     public void writeColorPointBYAttribute(DefaultClusterCallback callback, Integer value) {
-        writeColorPointBYAttribute(chipClusterPtr, callback, value, null);
+      writeColorPointBYAttribute(callback, value, 0);
     }
 
     public void writeColorPointBYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeColorPointBYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), COLOR_POINT_B_Y_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeColorPointBYAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeColorPointBYAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_POINT_B_Y_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COLOR_POINT_B_Y_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readColorPointBIntensityAttribute(
         ColorPointBIntensityAttributeCallback callback) {
-        readColorPointBIntensityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_POINT_B_INTENSITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COLOR_POINT_B_INTENSITY_ATTRIBUTE_ID, true);
     }
 
     public void writeColorPointBIntensityAttribute(DefaultClusterCallback callback, Integer value) {
-        writeColorPointBIntensityAttribute(chipClusterPtr, callback, value, null);
+      writeColorPointBIntensityAttribute(callback, value, 0);
     }
 
     public void writeColorPointBIntensityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeColorPointBIntensityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), COLOR_POINT_B_INTENSITY_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeColorPointBIntensityAttribute(
         ColorPointBIntensityAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeColorPointBIntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_POINT_B_INTENSITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COLOR_POINT_B_INTENSITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEnhancedCurrentHueAttribute(
         IntegerAttributeCallback callback) {
-        readEnhancedCurrentHueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENHANCED_CURRENT_HUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ENHANCED_CURRENT_HUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEnhancedCurrentHueAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEnhancedCurrentHueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENHANCED_CURRENT_HUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ENHANCED_CURRENT_HUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEnhancedColorModeAttribute(
         IntegerAttributeCallback callback) {
-        readEnhancedColorModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENHANCED_COLOR_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ENHANCED_COLOR_MODE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEnhancedColorModeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEnhancedColorModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENHANCED_COLOR_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ENHANCED_COLOR_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readColorLoopActiveAttribute(
         IntegerAttributeCallback callback) {
-        readColorLoopActiveAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_LOOP_ACTIVE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COLOR_LOOP_ACTIVE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeColorLoopActiveAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeColorLoopActiveAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_LOOP_ACTIVE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COLOR_LOOP_ACTIVE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readColorLoopDirectionAttribute(
         IntegerAttributeCallback callback) {
-        readColorLoopDirectionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_LOOP_DIRECTION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COLOR_LOOP_DIRECTION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeColorLoopDirectionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeColorLoopDirectionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_LOOP_DIRECTION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COLOR_LOOP_DIRECTION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readColorLoopTimeAttribute(
         IntegerAttributeCallback callback) {
-        readColorLoopTimeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_LOOP_TIME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COLOR_LOOP_TIME_ATTRIBUTE_ID, true);
     }
 
     public void subscribeColorLoopTimeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeColorLoopTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_LOOP_TIME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COLOR_LOOP_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readColorLoopStartEnhancedHueAttribute(
         IntegerAttributeCallback callback) {
-        readColorLoopStartEnhancedHueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_LOOP_START_ENHANCED_HUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COLOR_LOOP_START_ENHANCED_HUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeColorLoopStartEnhancedHueAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeColorLoopStartEnhancedHueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_LOOP_START_ENHANCED_HUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COLOR_LOOP_START_ENHANCED_HUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readColorLoopStoredEnhancedHueAttribute(
         IntegerAttributeCallback callback) {
-        readColorLoopStoredEnhancedHueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_LOOP_STORED_ENHANCED_HUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COLOR_LOOP_STORED_ENHANCED_HUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeColorLoopStoredEnhancedHueAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeColorLoopStoredEnhancedHueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_LOOP_STORED_ENHANCED_HUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COLOR_LOOP_STORED_ENHANCED_HUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readColorCapabilitiesAttribute(
         IntegerAttributeCallback callback) {
-        readColorCapabilitiesAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_CAPABILITIES_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COLOR_CAPABILITIES_ATTRIBUTE_ID, true);
     }
 
     public void subscribeColorCapabilitiesAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeColorCapabilitiesAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_CAPABILITIES_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COLOR_CAPABILITIES_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readColorTempPhysicalMinMiredsAttribute(
         IntegerAttributeCallback callback) {
-        readColorTempPhysicalMinMiredsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_TEMP_PHYSICAL_MIN_MIREDS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COLOR_TEMP_PHYSICAL_MIN_MIREDS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeColorTempPhysicalMinMiredsAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeColorTempPhysicalMinMiredsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_TEMP_PHYSICAL_MIN_MIREDS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COLOR_TEMP_PHYSICAL_MIN_MIREDS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readColorTempPhysicalMaxMiredsAttribute(
         IntegerAttributeCallback callback) {
-        readColorTempPhysicalMaxMiredsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_TEMP_PHYSICAL_MAX_MIREDS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COLOR_TEMP_PHYSICAL_MAX_MIREDS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeColorTempPhysicalMaxMiredsAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeColorTempPhysicalMaxMiredsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COLOR_TEMP_PHYSICAL_MAX_MIREDS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COLOR_TEMP_PHYSICAL_MAX_MIREDS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCoupleColorTempToLevelMinMiredsAttribute(
         IntegerAttributeCallback callback) {
-        readCoupleColorTempToLevelMinMiredsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COUPLE_COLOR_TEMP_TO_LEVEL_MIN_MIREDS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, COUPLE_COLOR_TEMP_TO_LEVEL_MIN_MIREDS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCoupleColorTempToLevelMinMiredsAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCoupleColorTempToLevelMinMiredsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, COUPLE_COLOR_TEMP_TO_LEVEL_MIN_MIREDS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, COUPLE_COLOR_TEMP_TO_LEVEL_MIN_MIREDS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readStartUpColorTemperatureMiredsAttribute(
         StartUpColorTemperatureMiredsAttributeCallback callback) {
-        readStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, START_UP_COLOR_TEMPERATURE_MIREDS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, START_UP_COLOR_TEMPERATURE_MIREDS_ATTRIBUTE_ID, true);
     }
 
     public void writeStartUpColorTemperatureMiredsAttribute(DefaultClusterCallback callback, Integer value) {
-        writeStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback, value, null);
+      writeStartUpColorTemperatureMiredsAttribute(callback, value, 0);
     }
 
     public void writeStartUpColorTemperatureMiredsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), START_UP_COLOR_TEMPERATURE_MIREDS_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeStartUpColorTemperatureMiredsAttribute(
         StartUpColorTemperatureMiredsAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, START_UP_COLOR_TEMPERATURE_MIREDS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, START_UP_COLOR_TEMPERATURE_MIREDS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readColorTemperatureMiredsAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeColorTemperatureMiredsAttribute(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 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 readNumberOfPrimariesAttribute(long chipClusterPtr, NumberOfPrimariesAttributeCallback callback);
-
-    private native void subscribeNumberOfPrimariesAttribute(long chipClusterPtr, NumberOfPrimariesAttributeCallback 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, Primary1IntensityAttributeCallback callback);
-
-    private native void subscribePrimary1IntensityAttribute(long chipClusterPtr, Primary1IntensityAttributeCallback 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, Primary2IntensityAttributeCallback callback);
-
-    private native void subscribePrimary2IntensityAttribute(long chipClusterPtr, Primary2IntensityAttributeCallback 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, Primary3IntensityAttributeCallback callback);
-
-    private native void subscribePrimary3IntensityAttribute(long chipClusterPtr, Primary3IntensityAttributeCallback 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, Primary4IntensityAttributeCallback callback);
-
-    private native void subscribePrimary4IntensityAttribute(long chipClusterPtr, Primary4IntensityAttributeCallback 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, Primary5IntensityAttributeCallback callback);
-
-    private native void subscribePrimary5IntensityAttribute(long chipClusterPtr, Primary5IntensityAttributeCallback 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, Primary6IntensityAttributeCallback callback);
-
-    private native void subscribePrimary6IntensityAttribute(long chipClusterPtr, Primary6IntensityAttributeCallback 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);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    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, ColorPointRIntensityAttributeCallback callback);
-
-    private native void writeColorPointRIntensityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeColorPointRIntensityAttribute(long chipClusterPtr, ColorPointRIntensityAttributeCallback 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, ColorPointGIntensityAttributeCallback callback);
-
-    private native void writeColorPointGIntensityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeColorPointGIntensityAttribute(long chipClusterPtr, ColorPointGIntensityAttributeCallback 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, ColorPointBIntensityAttributeCallback callback);
-
-    private native void writeColorPointBIntensityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeColorPointBIntensityAttribute(long chipClusterPtr, ColorPointBIntensityAttributeCallback 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 readColorTempPhysicalMinMiredsAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeColorTempPhysicalMinMiredsAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readColorTempPhysicalMaxMiredsAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeColorTempPhysicalMaxMiredsAttribute(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, StartUpColorTemperatureMiredsAttributeCallback callback);
-
-    private native void writeStartUpColorTemperatureMiredsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeStartUpColorTemperatureMiredsAttribute(long chipClusterPtr, StartUpColorTemperatureMiredsAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class BallastConfigurationCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 769L;
 
+    private static final long PHYSICAL_MIN_LEVEL_ATTRIBUTE_ID = 0L;
+    private static final long PHYSICAL_MAX_LEVEL_ATTRIBUTE_ID = 1L;
+    private static final long BALLAST_STATUS_ATTRIBUTE_ID = 2L;
+    private static final long MIN_LEVEL_ATTRIBUTE_ID = 16L;
+    private static final long MAX_LEVEL_ATTRIBUTE_ID = 17L;
+    private static final long INTRINSIC_BALLAST_FACTOR_ATTRIBUTE_ID = 20L;
+    private static final long BALLAST_FACTOR_ADJUSTMENT_ATTRIBUTE_ID = 21L;
+    private static final long LAMP_QUANTITY_ATTRIBUTE_ID = 32L;
+    private static final long LAMP_TYPE_ATTRIBUTE_ID = 48L;
+    private static final long LAMP_MANUFACTURER_ATTRIBUTE_ID = 49L;
+    private static final long LAMP_RATED_HOURS_ATTRIBUTE_ID = 50L;
+    private static final long LAMP_BURN_HOURS_ATTRIBUTE_ID = 51L;
+    private static final long LAMP_ALARM_MODE_ATTRIBUTE_ID = 52L;
+    private static final long LAMP_BURN_HOURS_TRIP_POINT_ATTRIBUTE_ID = 53L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public BallastConfigurationCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface IntrinsicBallastFactorAttributeCallback {
+    public interface IntrinsicBallastFactorAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface BallastFactorAdjustmentAttributeCallback {
+    public interface BallastFactorAdjustmentAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface LampRatedHoursAttributeCallback {
+    public interface LampRatedHoursAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface LampBurnHoursAttributeCallback {
+    public interface LampBurnHoursAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface LampBurnHoursTripPointAttributeCallback {
+    public interface LampBurnHoursTripPointAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readPhysicalMinLevelAttribute(
         IntegerAttributeCallback callback) {
-        readPhysicalMinLevelAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PHYSICAL_MIN_LEVEL_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PHYSICAL_MIN_LEVEL_ATTRIBUTE_ID, true);
     }
 
     public void subscribePhysicalMinLevelAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePhysicalMinLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PHYSICAL_MIN_LEVEL_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PHYSICAL_MIN_LEVEL_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPhysicalMaxLevelAttribute(
         IntegerAttributeCallback callback) {
-        readPhysicalMaxLevelAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PHYSICAL_MAX_LEVEL_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PHYSICAL_MAX_LEVEL_ATTRIBUTE_ID, true);
     }
 
     public void subscribePhysicalMaxLevelAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePhysicalMaxLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PHYSICAL_MAX_LEVEL_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PHYSICAL_MAX_LEVEL_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBallastStatusAttribute(
         IntegerAttributeCallback callback) {
-        readBallastStatusAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BALLAST_STATUS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BALLAST_STATUS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeBallastStatusAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBallastStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BALLAST_STATUS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BALLAST_STATUS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinLevelAttribute(
         IntegerAttributeCallback callback) {
-        readMinLevelAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_LEVEL_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_LEVEL_ATTRIBUTE_ID, true);
     }
 
     public void writeMinLevelAttribute(DefaultClusterCallback callback, Integer value) {
-        writeMinLevelAttribute(chipClusterPtr, callback, value, null);
+      writeMinLevelAttribute(callback, value, 0);
     }
 
     public void writeMinLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeMinLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), MIN_LEVEL_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeMinLevelAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_LEVEL_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_LEVEL_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxLevelAttribute(
         IntegerAttributeCallback callback) {
-        readMaxLevelAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_LEVEL_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_LEVEL_ATTRIBUTE_ID, true);
     }
 
     public void writeMaxLevelAttribute(DefaultClusterCallback callback, Integer value) {
-        writeMaxLevelAttribute(chipClusterPtr, callback, value, null);
+      writeMaxLevelAttribute(callback, value, 0);
     }
 
     public void writeMaxLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeMaxLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), MAX_LEVEL_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeMaxLevelAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_LEVEL_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_LEVEL_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readIntrinsicBallastFactorAttribute(
         IntrinsicBallastFactorAttributeCallback callback) {
-        readIntrinsicBallastFactorAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INTRINSIC_BALLAST_FACTOR_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INTRINSIC_BALLAST_FACTOR_ATTRIBUTE_ID, true);
     }
 
     public void writeIntrinsicBallastFactorAttribute(DefaultClusterCallback callback, Integer value) {
-        writeIntrinsicBallastFactorAttribute(chipClusterPtr, callback, value, null);
+      writeIntrinsicBallastFactorAttribute(callback, value, 0);
     }
 
     public void writeIntrinsicBallastFactorAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeIntrinsicBallastFactorAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), INTRINSIC_BALLAST_FACTOR_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeIntrinsicBallastFactorAttribute(
         IntrinsicBallastFactorAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeIntrinsicBallastFactorAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INTRINSIC_BALLAST_FACTOR_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INTRINSIC_BALLAST_FACTOR_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readBallastFactorAdjustmentAttribute(
         BallastFactorAdjustmentAttributeCallback callback) {
-        readBallastFactorAdjustmentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BALLAST_FACTOR_ADJUSTMENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BALLAST_FACTOR_ADJUSTMENT_ATTRIBUTE_ID, true);
     }
 
     public void writeBallastFactorAdjustmentAttribute(DefaultClusterCallback callback, Integer value) {
-        writeBallastFactorAdjustmentAttribute(chipClusterPtr, callback, value, null);
+      writeBallastFactorAdjustmentAttribute(callback, value, 0);
     }
 
     public void writeBallastFactorAdjustmentAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeBallastFactorAdjustmentAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), BALLAST_FACTOR_ADJUSTMENT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeBallastFactorAdjustmentAttribute(
         BallastFactorAdjustmentAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBallastFactorAdjustmentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BALLAST_FACTOR_ADJUSTMENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BALLAST_FACTOR_ADJUSTMENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLampQuantityAttribute(
         IntegerAttributeCallback callback) {
-        readLampQuantityAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAMP_QUANTITY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LAMP_QUANTITY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLampQuantityAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLampQuantityAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAMP_QUANTITY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LAMP_QUANTITY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLampTypeAttribute(
         CharStringAttributeCallback callback) {
-        readLampTypeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAMP_TYPE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LAMP_TYPE_ATTRIBUTE_ID, true);
     }
 
     public void writeLampTypeAttribute(DefaultClusterCallback callback, String value) {
-        writeLampTypeAttribute(chipClusterPtr, callback, value, null);
+      writeLampTypeAttribute(callback, value, 0);
     }
 
     public void writeLampTypeAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) {
-        writeLampTypeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new StringType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LAMP_TYPE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeLampTypeAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLampTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAMP_TYPE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LAMP_TYPE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLampManufacturerAttribute(
         CharStringAttributeCallback callback) {
-        readLampManufacturerAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAMP_MANUFACTURER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LAMP_MANUFACTURER_ATTRIBUTE_ID, true);
     }
 
     public void writeLampManufacturerAttribute(DefaultClusterCallback callback, String value) {
-        writeLampManufacturerAttribute(chipClusterPtr, callback, value, null);
+      writeLampManufacturerAttribute(callback, value, 0);
     }
 
     public void writeLampManufacturerAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) {
-        writeLampManufacturerAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new StringType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LAMP_MANUFACTURER_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeLampManufacturerAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLampManufacturerAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAMP_MANUFACTURER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LAMP_MANUFACTURER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLampRatedHoursAttribute(
         LampRatedHoursAttributeCallback callback) {
-        readLampRatedHoursAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAMP_RATED_HOURS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LAMP_RATED_HOURS_ATTRIBUTE_ID, true);
     }
 
     public void writeLampRatedHoursAttribute(DefaultClusterCallback callback, Long value) {
-        writeLampRatedHoursAttribute(chipClusterPtr, callback, value, null);
+      writeLampRatedHoursAttribute(callback, value, 0);
     }
 
     public void writeLampRatedHoursAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeLampRatedHoursAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LAMP_RATED_HOURS_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeLampRatedHoursAttribute(
         LampRatedHoursAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLampRatedHoursAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAMP_RATED_HOURS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LAMP_RATED_HOURS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLampBurnHoursAttribute(
         LampBurnHoursAttributeCallback callback) {
-        readLampBurnHoursAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAMP_BURN_HOURS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LAMP_BURN_HOURS_ATTRIBUTE_ID, true);
     }
 
     public void writeLampBurnHoursAttribute(DefaultClusterCallback callback, Long value) {
-        writeLampBurnHoursAttribute(chipClusterPtr, callback, value, null);
+      writeLampBurnHoursAttribute(callback, value, 0);
     }
 
     public void writeLampBurnHoursAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeLampBurnHoursAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LAMP_BURN_HOURS_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeLampBurnHoursAttribute(
         LampBurnHoursAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLampBurnHoursAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAMP_BURN_HOURS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LAMP_BURN_HOURS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLampAlarmModeAttribute(
         IntegerAttributeCallback callback) {
-        readLampAlarmModeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAMP_ALARM_MODE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LAMP_ALARM_MODE_ATTRIBUTE_ID, true);
     }
 
     public void writeLampAlarmModeAttribute(DefaultClusterCallback callback, Integer value) {
-        writeLampAlarmModeAttribute(chipClusterPtr, callback, value, null);
+      writeLampAlarmModeAttribute(callback, value, 0);
     }
 
     public void writeLampAlarmModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeLampAlarmModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LAMP_ALARM_MODE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeLampAlarmModeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLampAlarmModeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAMP_ALARM_MODE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LAMP_ALARM_MODE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLampBurnHoursTripPointAttribute(
         LampBurnHoursTripPointAttributeCallback callback) {
-        readLampBurnHoursTripPointAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAMP_BURN_HOURS_TRIP_POINT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LAMP_BURN_HOURS_TRIP_POINT_ATTRIBUTE_ID, true);
     }
 
     public void writeLampBurnHoursTripPointAttribute(DefaultClusterCallback callback, Long value) {
-        writeLampBurnHoursTripPointAttribute(chipClusterPtr, callback, value, null);
+      writeLampBurnHoursTripPointAttribute(callback, value, 0);
     }
 
     public void writeLampBurnHoursTripPointAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeLampBurnHoursTripPointAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LAMP_BURN_HOURS_TRIP_POINT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeLampBurnHoursTripPointAttribute(
         LampBurnHoursTripPointAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLampBurnHoursTripPointAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LAMP_BURN_HOURS_TRIP_POINT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LAMP_BURN_HOURS_TRIP_POINT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
+  }
 
-    private native void readPhysicalMinLevelAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+  public static class IlluminanceMeasurementCluster extends BaseChipCluster {
+    public static final long CLUSTER_ID = 1024L;
 
-    private native void subscribePhysicalMinLevelAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    private static final long MEASURED_VALUE_ATTRIBUTE_ID = 0L;
+    private static final long MIN_MEASURED_VALUE_ATTRIBUTE_ID = 1L;
+    private static final long MAX_MEASURED_VALUE_ATTRIBUTE_ID = 2L;
+    private static final long TOLERANCE_ATTRIBUTE_ID = 3L;
+    private static final long LIGHT_SENSOR_TYPE_ATTRIBUTE_ID = 4L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
 
-    private native void readPhysicalMaxLevelAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public IlluminanceMeasurementCluster(long devicePtr, int endpointId) {
+      super(devicePtr, endpointId, CLUSTER_ID);
+    }
 
-    private native void subscribePhysicalMaxLevelAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    @Override
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    private native void readBallastStatusAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public interface MeasuredValueAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Integer value);
+    }
 
-    private native void subscribeBallastStatusAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public interface MinMeasuredValueAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Integer value);
+    }
 
-    private native void readMinLevelAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public interface MaxMeasuredValueAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Integer value);
+    }
 
-    private native void writeMinLevelAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    public interface LightSensorTypeAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Integer value);
+    }
 
-    private native void subscribeMinLevelAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void readMaxLevelAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void writeMaxLevelAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void subscribeMaxLevelAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readIntrinsicBallastFactorAttribute(long chipClusterPtr, IntrinsicBallastFactorAttributeCallback callback);
-
-    private native void writeIntrinsicBallastFactorAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeIntrinsicBallastFactorAttribute(long chipClusterPtr, IntrinsicBallastFactorAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readBallastFactorAdjustmentAttribute(long chipClusterPtr, BallastFactorAdjustmentAttributeCallback callback);
-
-    private native void writeBallastFactorAdjustmentAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeBallastFactorAdjustmentAttribute(long chipClusterPtr, BallastFactorAdjustmentAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLampQuantityAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeLampQuantityAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLampTypeAttribute(long chipClusterPtr, CharStringAttributeCallback callback);
-
-    private native void writeLampTypeAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeLampTypeAttribute(long chipClusterPtr, CharStringAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLampManufacturerAttribute(long chipClusterPtr, CharStringAttributeCallback callback);
-
-    private native void writeLampManufacturerAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeLampManufacturerAttribute(long chipClusterPtr, CharStringAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLampRatedHoursAttribute(long chipClusterPtr, LampRatedHoursAttributeCallback callback);
-
-    private native void writeLampRatedHoursAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeLampRatedHoursAttribute(long chipClusterPtr, LampRatedHoursAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLampBurnHoursAttribute(long chipClusterPtr, LampBurnHoursAttributeCallback callback);
-
-    private native void writeLampBurnHoursAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeLampBurnHoursAttribute(long chipClusterPtr, LampBurnHoursAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLampAlarmModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeLampAlarmModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeLampAlarmModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLampBurnHoursTripPointAttribute(long chipClusterPtr, LampBurnHoursTripPointAttributeCallback callback);
-
-    private native void writeLampBurnHoursTripPointAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeLampBurnHoursTripPointAttribute(long chipClusterPtr, LampBurnHoursTripPointAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-  }
-
-  public static class IlluminanceMeasurementCluster extends BaseChipCluster {
-    public static final long CLUSTER_ID = 1024L;
-
-    public IlluminanceMeasurementCluster(long devicePtr, int endpointId) {
-      super(devicePtr, 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(long subscriptionId) {}
-    }
-
-    public interface MinMeasuredValueAttributeCallback {
-      void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface MaxMeasuredValueAttributeCallback {
-      void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface LightSensorTypeAttributeCallback {
-      void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface GeneratedCommandListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface AcceptedCommandListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface EventListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback) {
-        readMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback) {
-        readMinMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback) {
-        readMaxMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readToleranceAttribute(
         IntegerAttributeCallback callback) {
-        readToleranceAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TOLERANCE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TOLERANCE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeToleranceAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TOLERANCE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TOLERANCE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLightSensorTypeAttribute(
         LightSensorTypeAttributeCallback callback) {
-        readLightSensorTypeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LIGHT_SENSOR_TYPE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LIGHT_SENSOR_TYPE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLightSensorTypeAttribute(
         LightSensorTypeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLightSensorTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LIGHT_SENSOR_TYPE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LIGHT_SENSOR_TYPE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    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 readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class TemperatureMeasurementCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1026L;
 
+    private static final long MEASURED_VALUE_ATTRIBUTE_ID = 0L;
+    private static final long MIN_MEASURED_VALUE_ATTRIBUTE_ID = 1L;
+    private static final long MAX_MEASURED_VALUE_ATTRIBUTE_ID = 2L;
+    private static final long TOLERANCE_ATTRIBUTE_ID = 3L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public TemperatureMeasurementCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface MeasuredValueAttributeCallback {
+    public interface MeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MinMeasuredValueAttributeCallback {
+    public interface MinMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MaxMeasuredValueAttributeCallback {
+    public interface MaxMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback) {
-        readMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback) {
-        readMinMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback) {
-        readMaxMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readToleranceAttribute(
         IntegerAttributeCallback callback) {
-        readToleranceAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TOLERANCE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TOLERANCE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeToleranceAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TOLERANCE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TOLERANCE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class PressureMeasurementCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1027L;
 
+    private static final long MEASURED_VALUE_ATTRIBUTE_ID = 0L;
+    private static final long MIN_MEASURED_VALUE_ATTRIBUTE_ID = 1L;
+    private static final long MAX_MEASURED_VALUE_ATTRIBUTE_ID = 2L;
+    private static final long TOLERANCE_ATTRIBUTE_ID = 3L;
+    private static final long SCALED_VALUE_ATTRIBUTE_ID = 16L;
+    private static final long MIN_SCALED_VALUE_ATTRIBUTE_ID = 17L;
+    private static final long MAX_SCALED_VALUE_ATTRIBUTE_ID = 18L;
+    private static final long SCALED_TOLERANCE_ATTRIBUTE_ID = 19L;
+    private static final long SCALE_ATTRIBUTE_ID = 20L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public PressureMeasurementCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface MeasuredValueAttributeCallback {
+    public interface MeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MinMeasuredValueAttributeCallback {
+    public interface MinMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MaxMeasuredValueAttributeCallback {
+    public interface MaxMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface ScaledValueAttributeCallback {
+    public interface ScaledValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MinScaledValueAttributeCallback {
+    public interface MinScaledValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MaxScaledValueAttributeCallback {
+    public interface MaxScaledValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback) {
-        readMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback) {
-        readMinMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback) {
-        readMaxMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readToleranceAttribute(
         IntegerAttributeCallback callback) {
-        readToleranceAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TOLERANCE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TOLERANCE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeToleranceAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TOLERANCE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TOLERANCE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readScaledValueAttribute(
         ScaledValueAttributeCallback callback) {
-        readScaledValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SCALED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SCALED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeScaledValueAttribute(
         ScaledValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeScaledValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SCALED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SCALED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinScaledValueAttribute(
         MinScaledValueAttributeCallback callback) {
-        readMinScaledValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_SCALED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_SCALED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinScaledValueAttribute(
         MinScaledValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinScaledValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_SCALED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_SCALED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxScaledValueAttribute(
         MaxScaledValueAttributeCallback callback) {
-        readMaxScaledValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_SCALED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_SCALED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxScaledValueAttribute(
         MaxScaledValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxScaledValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_SCALED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_SCALED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readScaledToleranceAttribute(
         IntegerAttributeCallback callback) {
-        readScaledToleranceAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SCALED_TOLERANCE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SCALED_TOLERANCE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeScaledToleranceAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeScaledToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SCALED_TOLERANCE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SCALED_TOLERANCE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readScaleAttribute(
         IntegerAttributeCallback callback) {
-        readScaleAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SCALE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SCALE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeScaleAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeScaleAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SCALE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SCALE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    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 readScaledValueAttribute(long chipClusterPtr, ScaledValueAttributeCallback callback);
-
-    private native void subscribeScaledValueAttribute(long chipClusterPtr, ScaledValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMinScaledValueAttribute(long chipClusterPtr, MinScaledValueAttributeCallback callback);
-
-    private native void subscribeMinScaledValueAttribute(long chipClusterPtr, MinScaledValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMaxScaledValueAttribute(long chipClusterPtr, MaxScaledValueAttributeCallback callback);
-
-    private native void subscribeMaxScaledValueAttribute(long chipClusterPtr, MaxScaledValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readScaledToleranceAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeScaledToleranceAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readScaleAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeScaleAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class FlowMeasurementCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1028L;
 
+    private static final long MEASURED_VALUE_ATTRIBUTE_ID = 0L;
+    private static final long MIN_MEASURED_VALUE_ATTRIBUTE_ID = 1L;
+    private static final long MAX_MEASURED_VALUE_ATTRIBUTE_ID = 2L;
+    private static final long TOLERANCE_ATTRIBUTE_ID = 3L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public FlowMeasurementCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface MeasuredValueAttributeCallback {
+    public interface MeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MinMeasuredValueAttributeCallback {
+    public interface MinMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MaxMeasuredValueAttributeCallback {
+    public interface MaxMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback) {
-        readMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback) {
-        readMinMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback) {
-        readMaxMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readToleranceAttribute(
         IntegerAttributeCallback callback) {
-        readToleranceAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TOLERANCE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TOLERANCE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeToleranceAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TOLERANCE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TOLERANCE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
+  }
 
-    private native void readMeasuredValueAttribute(long chipClusterPtr, MeasuredValueAttributeCallback callback);
+  public static class RelativeHumidityMeasurementCluster extends BaseChipCluster {
+    public static final long CLUSTER_ID = 1029L;
 
-    private native void subscribeMeasuredValueAttribute(long chipClusterPtr, MeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
+    private static final long MEASURED_VALUE_ATTRIBUTE_ID = 0L;
+    private static final long MIN_MEASURED_VALUE_ATTRIBUTE_ID = 1L;
+    private static final long MAX_MEASURED_VALUE_ATTRIBUTE_ID = 2L;
+    private static final long TOLERANCE_ATTRIBUTE_ID = 3L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
 
-    private native void readMinMeasuredValueAttribute(long chipClusterPtr, MinMeasuredValueAttributeCallback callback);
+    public RelativeHumidityMeasurementCluster(long devicePtr, int endpointId) {
+      super(devicePtr, endpointId, CLUSTER_ID);
+    }
 
-    private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
+    @Override
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    private native void readMaxMeasuredValueAttribute(long chipClusterPtr, MaxMeasuredValueAttributeCallback callback);
+    public interface MeasuredValueAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Integer value);
+    }
 
-    private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
+    public interface MinMeasuredValueAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Integer value);
+    }
 
-    private native void readToleranceAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public interface MaxMeasuredValueAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Integer value);
+    }
 
-    private native void subscribeToleranceAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
+    }
 
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-  }
-
-  public static class 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 MeasuredValueAttributeCallback {
-      void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface MinMeasuredValueAttributeCallback {
-      void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface MaxMeasuredValueAttributeCallback {
-      void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface GeneratedCommandListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface AcceptedCommandListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface AttributeListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback) {
-        readMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback) {
-        readMinMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback) {
-        readMaxMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readToleranceAttribute(
         IntegerAttributeCallback callback) {
-        readToleranceAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TOLERANCE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TOLERANCE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeToleranceAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TOLERANCE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TOLERANCE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class OccupancySensingCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1030L;
 
+    private static final long OCCUPANCY_ATTRIBUTE_ID = 0L;
+    private static final long OCCUPANCY_SENSOR_TYPE_ATTRIBUTE_ID = 1L;
+    private static final long OCCUPANCY_SENSOR_TYPE_BITMAP_ATTRIBUTE_ID = 2L;
+    private static final long P_I_R_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID = 16L;
+    private static final long P_I_R_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID = 17L;
+    private static final long P_I_R_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID = 18L;
+    private static final long ULTRASONIC_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID = 32L;
+    private static final long ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID = 33L;
+    private static final long ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID = 34L;
+    private static final long PHYSICAL_CONTACT_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID = 48L;
+    private static final long PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID = 49L;
+    private static final long PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID = 50L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public OccupancySensingCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readOccupancyAttribute(
         IntegerAttributeCallback callback) {
-        readOccupancyAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OCCUPANCY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OCCUPANCY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeOccupancyAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOccupancyAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OCCUPANCY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OCCUPANCY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOccupancySensorTypeAttribute(
         IntegerAttributeCallback callback) {
-        readOccupancySensorTypeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OCCUPANCY_SENSOR_TYPE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OCCUPANCY_SENSOR_TYPE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeOccupancySensorTypeAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOccupancySensorTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OCCUPANCY_SENSOR_TYPE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OCCUPANCY_SENSOR_TYPE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOccupancySensorTypeBitmapAttribute(
         IntegerAttributeCallback callback) {
-        readOccupancySensorTypeBitmapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OCCUPANCY_SENSOR_TYPE_BITMAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OCCUPANCY_SENSOR_TYPE_BITMAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeOccupancySensorTypeBitmapAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOccupancySensorTypeBitmapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OCCUPANCY_SENSOR_TYPE_BITMAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OCCUPANCY_SENSOR_TYPE_BITMAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPIROccupiedToUnoccupiedDelayAttribute(
         IntegerAttributeCallback callback) {
-        readPIROccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, P_I_R_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, P_I_R_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID, true);
     }
 
     public void writePIROccupiedToUnoccupiedDelayAttribute(DefaultClusterCallback callback, Integer value) {
-        writePIROccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback, value, null);
+      writePIROccupiedToUnoccupiedDelayAttribute(callback, value, 0);
     }
 
     public void writePIROccupiedToUnoccupiedDelayAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writePIROccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), P_I_R_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribePIROccupiedToUnoccupiedDelayAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePIROccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, P_I_R_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, P_I_R_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPIRUnoccupiedToOccupiedDelayAttribute(
         IntegerAttributeCallback callback) {
-        readPIRUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, P_I_R_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, P_I_R_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID, true);
     }
 
     public void writePIRUnoccupiedToOccupiedDelayAttribute(DefaultClusterCallback callback, Integer value) {
-        writePIRUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback, value, null);
+      writePIRUnoccupiedToOccupiedDelayAttribute(callback, value, 0);
     }
 
     public void writePIRUnoccupiedToOccupiedDelayAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writePIRUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), P_I_R_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribePIRUnoccupiedToOccupiedDelayAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePIRUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, P_I_R_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, P_I_R_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPIRUnoccupiedToOccupiedThresholdAttribute(
         IntegerAttributeCallback callback) {
-        readPIRUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, P_I_R_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, P_I_R_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID, true);
     }
 
     public void writePIRUnoccupiedToOccupiedThresholdAttribute(DefaultClusterCallback callback, Integer value) {
-        writePIRUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback, value, null);
+      writePIRUnoccupiedToOccupiedThresholdAttribute(callback, value, 0);
     }
 
     public void writePIRUnoccupiedToOccupiedThresholdAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writePIRUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), P_I_R_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribePIRUnoccupiedToOccupiedThresholdAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePIRUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, P_I_R_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, P_I_R_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUltrasonicOccupiedToUnoccupiedDelayAttribute(
         IntegerAttributeCallback callback) {
-        readUltrasonicOccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ULTRASONIC_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ULTRASONIC_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID, true);
     }
 
     public void writeUltrasonicOccupiedToUnoccupiedDelayAttribute(DefaultClusterCallback callback, Integer value) {
-        writeUltrasonicOccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback, value, null);
+      writeUltrasonicOccupiedToUnoccupiedDelayAttribute(callback, value, 0);
     }
 
     public void writeUltrasonicOccupiedToUnoccupiedDelayAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeUltrasonicOccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ULTRASONIC_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeUltrasonicOccupiedToUnoccupiedDelayAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUltrasonicOccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ULTRASONIC_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ULTRASONIC_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUltrasonicUnoccupiedToOccupiedDelayAttribute(
         IntegerAttributeCallback callback) {
-        readUltrasonicUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID, true);
     }
 
     public void writeUltrasonicUnoccupiedToOccupiedDelayAttribute(DefaultClusterCallback callback, Integer value) {
-        writeUltrasonicUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback, value, null);
+      writeUltrasonicUnoccupiedToOccupiedDelayAttribute(callback, value, 0);
     }
 
     public void writeUltrasonicUnoccupiedToOccupiedDelayAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeUltrasonicUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeUltrasonicUnoccupiedToOccupiedDelayAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUltrasonicUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUltrasonicUnoccupiedToOccupiedThresholdAttribute(
         IntegerAttributeCallback callback) {
-        readUltrasonicUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID, true);
     }
 
     public void writeUltrasonicUnoccupiedToOccupiedThresholdAttribute(DefaultClusterCallback callback, Integer value) {
-        writeUltrasonicUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback, value, null);
+      writeUltrasonicUnoccupiedToOccupiedThresholdAttribute(callback, value, 0);
     }
 
     public void writeUltrasonicUnoccupiedToOccupiedThresholdAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeUltrasonicUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeUltrasonicUnoccupiedToOccupiedThresholdAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUltrasonicUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPhysicalContactOccupiedToUnoccupiedDelayAttribute(
         IntegerAttributeCallback callback) {
-        readPhysicalContactOccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PHYSICAL_CONTACT_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PHYSICAL_CONTACT_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID, true);
     }
 
     public void writePhysicalContactOccupiedToUnoccupiedDelayAttribute(DefaultClusterCallback callback, Integer value) {
-        writePhysicalContactOccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback, value, null);
+      writePhysicalContactOccupiedToUnoccupiedDelayAttribute(callback, value, 0);
     }
 
     public void writePhysicalContactOccupiedToUnoccupiedDelayAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writePhysicalContactOccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), PHYSICAL_CONTACT_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribePhysicalContactOccupiedToUnoccupiedDelayAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePhysicalContactOccupiedToUnoccupiedDelayAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PHYSICAL_CONTACT_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PHYSICAL_CONTACT_OCCUPIED_TO_UNOCCUPIED_DELAY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPhysicalContactUnoccupiedToOccupiedDelayAttribute(
         IntegerAttributeCallback callback) {
-        readPhysicalContactUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID, true);
     }
 
     public void writePhysicalContactUnoccupiedToOccupiedDelayAttribute(DefaultClusterCallback callback, Integer value) {
-        writePhysicalContactUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback, value, null);
+      writePhysicalContactUnoccupiedToOccupiedDelayAttribute(callback, value, 0);
     }
 
     public void writePhysicalContactUnoccupiedToOccupiedDelayAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writePhysicalContactUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribePhysicalContactUnoccupiedToOccupiedDelayAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePhysicalContactUnoccupiedToOccupiedDelayAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_DELAY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPhysicalContactUnoccupiedToOccupiedThresholdAttribute(
         IntegerAttributeCallback callback) {
-        readPhysicalContactUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID, true);
     }
 
     public void writePhysicalContactUnoccupiedToOccupiedThresholdAttribute(DefaultClusterCallback callback, Integer value) {
-        writePhysicalContactUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback, value, null);
+      writePhysicalContactUnoccupiedToOccupiedThresholdAttribute(callback, value, 0);
     }
 
     public void writePhysicalContactUnoccupiedToOccupiedThresholdAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writePhysicalContactUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribePhysicalContactUnoccupiedToOccupiedThresholdAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePhysicalContactUnoccupiedToOccupiedThresholdAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_THRESHOLD_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readPIROccupiedToUnoccupiedDelayAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writePIROccupiedToUnoccupiedDelayAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribePIROccupiedToUnoccupiedDelayAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPIRUnoccupiedToOccupiedDelayAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writePIRUnoccupiedToOccupiedDelayAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribePIRUnoccupiedToOccupiedDelayAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPIRUnoccupiedToOccupiedThresholdAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writePIRUnoccupiedToOccupiedThresholdAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribePIRUnoccupiedToOccupiedThresholdAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readUltrasonicOccupiedToUnoccupiedDelayAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeUltrasonicOccupiedToUnoccupiedDelayAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeUltrasonicOccupiedToUnoccupiedDelayAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readUltrasonicUnoccupiedToOccupiedDelayAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeUltrasonicUnoccupiedToOccupiedDelayAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeUltrasonicUnoccupiedToOccupiedDelayAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readUltrasonicUnoccupiedToOccupiedThresholdAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeUltrasonicUnoccupiedToOccupiedThresholdAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeUltrasonicUnoccupiedToOccupiedThresholdAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPhysicalContactOccupiedToUnoccupiedDelayAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writePhysicalContactOccupiedToUnoccupiedDelayAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribePhysicalContactOccupiedToUnoccupiedDelayAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPhysicalContactUnoccupiedToOccupiedDelayAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writePhysicalContactUnoccupiedToOccupiedDelayAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribePhysicalContactUnoccupiedToOccupiedDelayAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPhysicalContactUnoccupiedToOccupiedThresholdAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writePhysicalContactUnoccupiedToOccupiedThresholdAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribePhysicalContactUnoccupiedToOccupiedThresholdAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class CarbonMonoxideConcentrationMeasurementCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1036L;
 
+    private static final long MEASURED_VALUE_ATTRIBUTE_ID = 0L;
+    private static final long MIN_MEASURED_VALUE_ATTRIBUTE_ID = 1L;
+    private static final long MAX_MEASURED_VALUE_ATTRIBUTE_ID = 2L;
+    private static final long PEAK_MEASURED_VALUE_ATTRIBUTE_ID = 3L;
+    private static final long PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID = 4L;
+    private static final long AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID = 5L;
+    private static final long AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID = 6L;
+    private static final long UNCERTAINTY_ATTRIBUTE_ID = 7L;
+    private static final long MEASUREMENT_UNIT_ATTRIBUTE_ID = 8L;
+    private static final long MEASUREMENT_MEDIUM_ATTRIBUTE_ID = 9L;
+    private static final long LEVEL_VALUE_ATTRIBUTE_ID = 10L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public CarbonMonoxideConcentrationMeasurementCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface MeasuredValueAttributeCallback {
+    public interface MeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MinMeasuredValueAttributeCallback {
+    public interface MinMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MaxMeasuredValueAttributeCallback {
+    public interface MaxMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface PeakMeasuredValueAttributeCallback {
+    public interface PeakMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AverageMeasuredValueAttributeCallback {
+    public interface AverageMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback) {
-        readMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback) {
-        readMinMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback) {
-        readMaxMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPeakMeasuredValueAttribute(
         PeakMeasuredValueAttributeCallback callback) {
-        readPeakMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PEAK_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribePeakMeasuredValueAttribute(
         PeakMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePeakMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PEAK_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPeakMeasuredValueWindowAttribute(
         LongAttributeCallback callback) {
-        readPeakMeasuredValueWindowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribePeakMeasuredValueWindowAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePeakMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageMeasuredValueAttribute(
         AverageMeasuredValueAttributeCallback callback) {
-        readAverageMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageMeasuredValueAttribute(
         AverageMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageMeasuredValueWindowAttribute(
         LongAttributeCallback callback) {
-        readAverageMeasuredValueWindowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageMeasuredValueWindowAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUncertaintyAttribute(
         FloatAttributeCallback callback) {
-        readUncertaintyAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNCERTAINTY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UNCERTAINTY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeUncertaintyAttribute(
         FloatAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUncertaintyAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNCERTAINTY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UNCERTAINTY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasurementUnitAttribute(
         IntegerAttributeCallback callback) {
-        readMeasurementUnitAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_UNIT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASUREMENT_UNIT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasurementUnitAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasurementUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_UNIT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASUREMENT_UNIT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasurementMediumAttribute(
         IntegerAttributeCallback callback) {
-        readMeasurementMediumAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_MEDIUM_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASUREMENT_MEDIUM_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasurementMediumAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasurementMediumAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_MEDIUM_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASUREMENT_MEDIUM_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLevelValueAttribute(
         IntegerAttributeCallback callback) {
-        readLevelValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEVEL_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LEVEL_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLevelValueAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLevelValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEVEL_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LEVEL_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readPeakMeasuredValueAttribute(long chipClusterPtr, PeakMeasuredValueAttributeCallback callback);
-
-    private native void subscribePeakMeasuredValueAttribute(long chipClusterPtr, PeakMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPeakMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribePeakMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageMeasuredValueAttribute(long chipClusterPtr, AverageMeasuredValueAttributeCallback callback);
-
-    private native void subscribeAverageMeasuredValueAttribute(long chipClusterPtr, AverageMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeAverageMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readUncertaintyAttribute(long chipClusterPtr, FloatAttributeCallback callback);
-
-    private native void subscribeUncertaintyAttribute(long chipClusterPtr, FloatAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMeasurementUnitAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMeasurementUnitAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMeasurementMediumAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMeasurementMediumAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLevelValueAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeLevelValueAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    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);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class CarbonDioxideConcentrationMeasurementCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1037L;
 
+    private static final long MEASURED_VALUE_ATTRIBUTE_ID = 0L;
+    private static final long MIN_MEASURED_VALUE_ATTRIBUTE_ID = 1L;
+    private static final long MAX_MEASURED_VALUE_ATTRIBUTE_ID = 2L;
+    private static final long PEAK_MEASURED_VALUE_ATTRIBUTE_ID = 3L;
+    private static final long PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID = 4L;
+    private static final long AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID = 5L;
+    private static final long AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID = 6L;
+    private static final long UNCERTAINTY_ATTRIBUTE_ID = 7L;
+    private static final long MEASUREMENT_UNIT_ATTRIBUTE_ID = 8L;
+    private static final long MEASUREMENT_MEDIUM_ATTRIBUTE_ID = 9L;
+    private static final long LEVEL_VALUE_ATTRIBUTE_ID = 10L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public CarbonDioxideConcentrationMeasurementCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface MeasuredValueAttributeCallback {
+    public interface MeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MinMeasuredValueAttributeCallback {
+    public interface MinMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MaxMeasuredValueAttributeCallback {
+    public interface MaxMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface PeakMeasuredValueAttributeCallback {
+    public interface PeakMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AverageMeasuredValueAttributeCallback {
+    public interface AverageMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback) {
-        readMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback) {
-        readMinMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback) {
-        readMaxMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPeakMeasuredValueAttribute(
         PeakMeasuredValueAttributeCallback callback) {
-        readPeakMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PEAK_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribePeakMeasuredValueAttribute(
         PeakMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePeakMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PEAK_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPeakMeasuredValueWindowAttribute(
         LongAttributeCallback callback) {
-        readPeakMeasuredValueWindowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribePeakMeasuredValueWindowAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePeakMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageMeasuredValueAttribute(
         AverageMeasuredValueAttributeCallback callback) {
-        readAverageMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageMeasuredValueAttribute(
         AverageMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageMeasuredValueWindowAttribute(
         LongAttributeCallback callback) {
-        readAverageMeasuredValueWindowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageMeasuredValueWindowAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUncertaintyAttribute(
         FloatAttributeCallback callback) {
-        readUncertaintyAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNCERTAINTY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UNCERTAINTY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeUncertaintyAttribute(
         FloatAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUncertaintyAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNCERTAINTY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UNCERTAINTY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasurementUnitAttribute(
         IntegerAttributeCallback callback) {
-        readMeasurementUnitAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_UNIT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASUREMENT_UNIT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasurementUnitAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasurementUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_UNIT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASUREMENT_UNIT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasurementMediumAttribute(
         IntegerAttributeCallback callback) {
-        readMeasurementMediumAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_MEDIUM_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASUREMENT_MEDIUM_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasurementMediumAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasurementMediumAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_MEDIUM_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASUREMENT_MEDIUM_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLevelValueAttribute(
         IntegerAttributeCallback callback) {
-        readLevelValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEVEL_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LEVEL_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLevelValueAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLevelValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEVEL_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LEVEL_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readPeakMeasuredValueAttribute(long chipClusterPtr, PeakMeasuredValueAttributeCallback callback);
-
-    private native void subscribePeakMeasuredValueAttribute(long chipClusterPtr, PeakMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPeakMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribePeakMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageMeasuredValueAttribute(long chipClusterPtr, AverageMeasuredValueAttributeCallback callback);
-
-    private native void subscribeAverageMeasuredValueAttribute(long chipClusterPtr, AverageMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeAverageMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readUncertaintyAttribute(long chipClusterPtr, FloatAttributeCallback callback);
-
-    private native void subscribeUncertaintyAttribute(long chipClusterPtr, FloatAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMeasurementUnitAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMeasurementUnitAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMeasurementMediumAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMeasurementMediumAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLevelValueAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeLevelValueAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class NitrogenDioxideConcentrationMeasurementCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1043L;
 
+    private static final long MEASURED_VALUE_ATTRIBUTE_ID = 0L;
+    private static final long MIN_MEASURED_VALUE_ATTRIBUTE_ID = 1L;
+    private static final long MAX_MEASURED_VALUE_ATTRIBUTE_ID = 2L;
+    private static final long PEAK_MEASURED_VALUE_ATTRIBUTE_ID = 3L;
+    private static final long PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID = 4L;
+    private static final long AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID = 5L;
+    private static final long AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID = 6L;
+    private static final long UNCERTAINTY_ATTRIBUTE_ID = 7L;
+    private static final long MEASUREMENT_UNIT_ATTRIBUTE_ID = 8L;
+    private static final long MEASUREMENT_MEDIUM_ATTRIBUTE_ID = 9L;
+    private static final long LEVEL_VALUE_ATTRIBUTE_ID = 10L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public NitrogenDioxideConcentrationMeasurementCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface MeasuredValueAttributeCallback {
+    public interface MeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MinMeasuredValueAttributeCallback {
+    public interface MinMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MaxMeasuredValueAttributeCallback {
+    public interface MaxMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface PeakMeasuredValueAttributeCallback {
+    public interface PeakMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AverageMeasuredValueAttributeCallback {
+    public interface AverageMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback) {
-        readMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback) {
-        readMinMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback) {
-        readMaxMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPeakMeasuredValueAttribute(
         PeakMeasuredValueAttributeCallback callback) {
-        readPeakMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PEAK_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribePeakMeasuredValueAttribute(
         PeakMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePeakMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PEAK_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPeakMeasuredValueWindowAttribute(
         LongAttributeCallback callback) {
-        readPeakMeasuredValueWindowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribePeakMeasuredValueWindowAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePeakMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageMeasuredValueAttribute(
         AverageMeasuredValueAttributeCallback callback) {
-        readAverageMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageMeasuredValueAttribute(
         AverageMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageMeasuredValueWindowAttribute(
         LongAttributeCallback callback) {
-        readAverageMeasuredValueWindowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageMeasuredValueWindowAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUncertaintyAttribute(
         FloatAttributeCallback callback) {
-        readUncertaintyAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNCERTAINTY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UNCERTAINTY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeUncertaintyAttribute(
         FloatAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUncertaintyAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNCERTAINTY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UNCERTAINTY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasurementUnitAttribute(
         IntegerAttributeCallback callback) {
-        readMeasurementUnitAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_UNIT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASUREMENT_UNIT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasurementUnitAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasurementUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_UNIT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASUREMENT_UNIT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasurementMediumAttribute(
         IntegerAttributeCallback callback) {
-        readMeasurementMediumAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_MEDIUM_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASUREMENT_MEDIUM_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasurementMediumAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasurementMediumAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_MEDIUM_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASUREMENT_MEDIUM_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLevelValueAttribute(
         IntegerAttributeCallback callback) {
-        readLevelValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEVEL_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LEVEL_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLevelValueAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLevelValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEVEL_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LEVEL_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readPeakMeasuredValueAttribute(long chipClusterPtr, PeakMeasuredValueAttributeCallback callback);
-
-    private native void subscribePeakMeasuredValueAttribute(long chipClusterPtr, PeakMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPeakMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribePeakMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageMeasuredValueAttribute(long chipClusterPtr, AverageMeasuredValueAttributeCallback callback);
-
-    private native void subscribeAverageMeasuredValueAttribute(long chipClusterPtr, AverageMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeAverageMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readUncertaintyAttribute(long chipClusterPtr, FloatAttributeCallback callback);
-
-    private native void subscribeUncertaintyAttribute(long chipClusterPtr, FloatAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMeasurementUnitAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMeasurementUnitAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readMeasurementMediumAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMeasurementMediumAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLevelValueAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeLevelValueAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class OzoneConcentrationMeasurementCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1045L;
 
+    private static final long MEASURED_VALUE_ATTRIBUTE_ID = 0L;
+    private static final long MIN_MEASURED_VALUE_ATTRIBUTE_ID = 1L;
+    private static final long MAX_MEASURED_VALUE_ATTRIBUTE_ID = 2L;
+    private static final long PEAK_MEASURED_VALUE_ATTRIBUTE_ID = 3L;
+    private static final long PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID = 4L;
+    private static final long AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID = 5L;
+    private static final long AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID = 6L;
+    private static final long UNCERTAINTY_ATTRIBUTE_ID = 7L;
+    private static final long MEASUREMENT_UNIT_ATTRIBUTE_ID = 8L;
+    private static final long MEASUREMENT_MEDIUM_ATTRIBUTE_ID = 9L;
+    private static final long LEVEL_VALUE_ATTRIBUTE_ID = 10L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public OzoneConcentrationMeasurementCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface MeasuredValueAttributeCallback {
+    public interface MeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MinMeasuredValueAttributeCallback {
+    public interface MinMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MaxMeasuredValueAttributeCallback {
+    public interface MaxMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface PeakMeasuredValueAttributeCallback {
+    public interface PeakMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AverageMeasuredValueAttributeCallback {
+    public interface AverageMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback) {
-        readMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback) {
-        readMinMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback) {
-        readMaxMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPeakMeasuredValueAttribute(
         PeakMeasuredValueAttributeCallback callback) {
-        readPeakMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PEAK_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribePeakMeasuredValueAttribute(
         PeakMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePeakMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PEAK_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPeakMeasuredValueWindowAttribute(
         LongAttributeCallback callback) {
-        readPeakMeasuredValueWindowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribePeakMeasuredValueWindowAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePeakMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageMeasuredValueAttribute(
         AverageMeasuredValueAttributeCallback callback) {
-        readAverageMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageMeasuredValueAttribute(
         AverageMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageMeasuredValueWindowAttribute(
         LongAttributeCallback callback) {
-        readAverageMeasuredValueWindowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageMeasuredValueWindowAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUncertaintyAttribute(
         FloatAttributeCallback callback) {
-        readUncertaintyAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNCERTAINTY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UNCERTAINTY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeUncertaintyAttribute(
         FloatAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUncertaintyAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNCERTAINTY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UNCERTAINTY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasurementUnitAttribute(
         IntegerAttributeCallback callback) {
-        readMeasurementUnitAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_UNIT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASUREMENT_UNIT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasurementUnitAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasurementUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_UNIT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASUREMENT_UNIT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasurementMediumAttribute(
         IntegerAttributeCallback callback) {
-        readMeasurementMediumAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_MEDIUM_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASUREMENT_MEDIUM_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasurementMediumAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasurementMediumAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_MEDIUM_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASUREMENT_MEDIUM_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLevelValueAttribute(
         IntegerAttributeCallback callback) {
-        readLevelValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEVEL_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LEVEL_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLevelValueAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLevelValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEVEL_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LEVEL_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readPeakMeasuredValueAttribute(long chipClusterPtr, PeakMeasuredValueAttributeCallback callback);
-
-    private native void subscribePeakMeasuredValueAttribute(long chipClusterPtr, PeakMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPeakMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribePeakMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageMeasuredValueAttribute(long chipClusterPtr, AverageMeasuredValueAttributeCallback callback);
-
-    private native void subscribeAverageMeasuredValueAttribute(long chipClusterPtr, AverageMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readAverageMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeAverageMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readUncertaintyAttribute(long chipClusterPtr, FloatAttributeCallback callback);
-
-    private native void subscribeUncertaintyAttribute(long chipClusterPtr, FloatAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMeasurementUnitAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMeasurementUnitAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMeasurementMediumAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMeasurementMediumAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLevelValueAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeLevelValueAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class Pm25ConcentrationMeasurementCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1066L;
 
+    private static final long MEASURED_VALUE_ATTRIBUTE_ID = 0L;
+    private static final long MIN_MEASURED_VALUE_ATTRIBUTE_ID = 1L;
+    private static final long MAX_MEASURED_VALUE_ATTRIBUTE_ID = 2L;
+    private static final long PEAK_MEASURED_VALUE_ATTRIBUTE_ID = 3L;
+    private static final long PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID = 4L;
+    private static final long AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID = 5L;
+    private static final long AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID = 6L;
+    private static final long UNCERTAINTY_ATTRIBUTE_ID = 7L;
+    private static final long MEASUREMENT_UNIT_ATTRIBUTE_ID = 8L;
+    private static final long MEASUREMENT_MEDIUM_ATTRIBUTE_ID = 9L;
+    private static final long LEVEL_VALUE_ATTRIBUTE_ID = 10L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public Pm25ConcentrationMeasurementCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface MeasuredValueAttributeCallback {
+    public interface MeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MinMeasuredValueAttributeCallback {
+    public interface MinMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MaxMeasuredValueAttributeCallback {
+    public interface MaxMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface PeakMeasuredValueAttributeCallback {
+    public interface PeakMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AverageMeasuredValueAttributeCallback {
+    public interface AverageMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback) {
-        readMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback) {
-        readMinMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback) {
-        readMaxMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPeakMeasuredValueAttribute(
         PeakMeasuredValueAttributeCallback callback) {
-        readPeakMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PEAK_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribePeakMeasuredValueAttribute(
         PeakMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePeakMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PEAK_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPeakMeasuredValueWindowAttribute(
         LongAttributeCallback callback) {
-        readPeakMeasuredValueWindowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribePeakMeasuredValueWindowAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePeakMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageMeasuredValueAttribute(
         AverageMeasuredValueAttributeCallback callback) {
-        readAverageMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageMeasuredValueAttribute(
         AverageMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageMeasuredValueWindowAttribute(
         LongAttributeCallback callback) {
-        readAverageMeasuredValueWindowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageMeasuredValueWindowAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUncertaintyAttribute(
         FloatAttributeCallback callback) {
-        readUncertaintyAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNCERTAINTY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UNCERTAINTY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeUncertaintyAttribute(
         FloatAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUncertaintyAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNCERTAINTY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UNCERTAINTY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasurementUnitAttribute(
         IntegerAttributeCallback callback) {
-        readMeasurementUnitAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_UNIT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASUREMENT_UNIT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasurementUnitAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasurementUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_UNIT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASUREMENT_UNIT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasurementMediumAttribute(
         IntegerAttributeCallback callback) {
-        readMeasurementMediumAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_MEDIUM_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASUREMENT_MEDIUM_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasurementMediumAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasurementMediumAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_MEDIUM_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASUREMENT_MEDIUM_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLevelValueAttribute(
         IntegerAttributeCallback callback) {
-        readLevelValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEVEL_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LEVEL_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLevelValueAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLevelValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEVEL_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LEVEL_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readPeakMeasuredValueAttribute(long chipClusterPtr, PeakMeasuredValueAttributeCallback callback);
-
-    private native void subscribePeakMeasuredValueAttribute(long chipClusterPtr, PeakMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPeakMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribePeakMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageMeasuredValueAttribute(long chipClusterPtr, AverageMeasuredValueAttributeCallback callback);
-
-    private native void subscribeAverageMeasuredValueAttribute(long chipClusterPtr, AverageMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeAverageMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readUncertaintyAttribute(long chipClusterPtr, FloatAttributeCallback callback);
-
-    private native void subscribeUncertaintyAttribute(long chipClusterPtr, FloatAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMeasurementUnitAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMeasurementUnitAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMeasurementMediumAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMeasurementMediumAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLevelValueAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeLevelValueAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class FormaldehydeConcentrationMeasurementCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1067L;
 
+    private static final long MEASURED_VALUE_ATTRIBUTE_ID = 0L;
+    private static final long MIN_MEASURED_VALUE_ATTRIBUTE_ID = 1L;
+    private static final long MAX_MEASURED_VALUE_ATTRIBUTE_ID = 2L;
+    private static final long PEAK_MEASURED_VALUE_ATTRIBUTE_ID = 3L;
+    private static final long PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID = 4L;
+    private static final long AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID = 5L;
+    private static final long AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID = 6L;
+    private static final long UNCERTAINTY_ATTRIBUTE_ID = 7L;
+    private static final long MEASUREMENT_UNIT_ATTRIBUTE_ID = 8L;
+    private static final long MEASUREMENT_MEDIUM_ATTRIBUTE_ID = 9L;
+    private static final long LEVEL_VALUE_ATTRIBUTE_ID = 10L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public FormaldehydeConcentrationMeasurementCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface MeasuredValueAttributeCallback {
+    public interface MeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MinMeasuredValueAttributeCallback {
+    public interface MinMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MaxMeasuredValueAttributeCallback {
+    public interface MaxMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface PeakMeasuredValueAttributeCallback {
+    public interface PeakMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AverageMeasuredValueAttributeCallback {
+    public interface AverageMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback) {
-        readMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback) {
-        readMinMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback) {
-        readMaxMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPeakMeasuredValueAttribute(
         PeakMeasuredValueAttributeCallback callback) {
-        readPeakMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PEAK_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribePeakMeasuredValueAttribute(
         PeakMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePeakMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PEAK_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPeakMeasuredValueWindowAttribute(
         LongAttributeCallback callback) {
-        readPeakMeasuredValueWindowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribePeakMeasuredValueWindowAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePeakMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageMeasuredValueAttribute(
         AverageMeasuredValueAttributeCallback callback) {
-        readAverageMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageMeasuredValueAttribute(
         AverageMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageMeasuredValueWindowAttribute(
         LongAttributeCallback callback) {
-        readAverageMeasuredValueWindowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageMeasuredValueWindowAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUncertaintyAttribute(
         FloatAttributeCallback callback) {
-        readUncertaintyAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNCERTAINTY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UNCERTAINTY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeUncertaintyAttribute(
         FloatAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUncertaintyAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNCERTAINTY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UNCERTAINTY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasurementUnitAttribute(
         IntegerAttributeCallback callback) {
-        readMeasurementUnitAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_UNIT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASUREMENT_UNIT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasurementUnitAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasurementUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_UNIT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASUREMENT_UNIT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasurementMediumAttribute(
         IntegerAttributeCallback callback) {
-        readMeasurementMediumAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_MEDIUM_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASUREMENT_MEDIUM_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasurementMediumAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasurementMediumAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_MEDIUM_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASUREMENT_MEDIUM_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLevelValueAttribute(
         IntegerAttributeCallback callback) {
-        readLevelValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEVEL_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LEVEL_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLevelValueAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLevelValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEVEL_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LEVEL_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readPeakMeasuredValueAttribute(long chipClusterPtr, PeakMeasuredValueAttributeCallback callback);
-
-    private native void subscribePeakMeasuredValueAttribute(long chipClusterPtr, PeakMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPeakMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribePeakMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageMeasuredValueAttribute(long chipClusterPtr, AverageMeasuredValueAttributeCallback callback);
-
-    private native void subscribeAverageMeasuredValueAttribute(long chipClusterPtr, AverageMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeAverageMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readUncertaintyAttribute(long chipClusterPtr, FloatAttributeCallback callback);
-
-    private native void subscribeUncertaintyAttribute(long chipClusterPtr, FloatAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMeasurementUnitAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMeasurementUnitAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMeasurementMediumAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMeasurementMediumAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLevelValueAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeLevelValueAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class Pm1ConcentrationMeasurementCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1068L;
 
+    private static final long MEASURED_VALUE_ATTRIBUTE_ID = 0L;
+    private static final long MIN_MEASURED_VALUE_ATTRIBUTE_ID = 1L;
+    private static final long MAX_MEASURED_VALUE_ATTRIBUTE_ID = 2L;
+    private static final long PEAK_MEASURED_VALUE_ATTRIBUTE_ID = 3L;
+    private static final long PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID = 4L;
+    private static final long AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID = 5L;
+    private static final long AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID = 6L;
+    private static final long UNCERTAINTY_ATTRIBUTE_ID = 7L;
+    private static final long MEASUREMENT_UNIT_ATTRIBUTE_ID = 8L;
+    private static final long MEASUREMENT_MEDIUM_ATTRIBUTE_ID = 9L;
+    private static final long LEVEL_VALUE_ATTRIBUTE_ID = 10L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public Pm1ConcentrationMeasurementCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface MeasuredValueAttributeCallback {
+    public interface MeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MinMeasuredValueAttributeCallback {
+    public interface MinMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MaxMeasuredValueAttributeCallback {
+    public interface MaxMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface PeakMeasuredValueAttributeCallback {
+    public interface PeakMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AverageMeasuredValueAttributeCallback {
+    public interface AverageMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback) {
-        readMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback) {
-        readMinMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback) {
-        readMaxMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPeakMeasuredValueAttribute(
         PeakMeasuredValueAttributeCallback callback) {
-        readPeakMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PEAK_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribePeakMeasuredValueAttribute(
         PeakMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePeakMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PEAK_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPeakMeasuredValueWindowAttribute(
         LongAttributeCallback callback) {
-        readPeakMeasuredValueWindowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribePeakMeasuredValueWindowAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePeakMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageMeasuredValueAttribute(
         AverageMeasuredValueAttributeCallback callback) {
-        readAverageMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageMeasuredValueAttribute(
         AverageMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageMeasuredValueWindowAttribute(
         LongAttributeCallback callback) {
-        readAverageMeasuredValueWindowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageMeasuredValueWindowAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUncertaintyAttribute(
         FloatAttributeCallback callback) {
-        readUncertaintyAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNCERTAINTY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UNCERTAINTY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeUncertaintyAttribute(
         FloatAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUncertaintyAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNCERTAINTY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UNCERTAINTY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasurementUnitAttribute(
         IntegerAttributeCallback callback) {
-        readMeasurementUnitAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_UNIT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASUREMENT_UNIT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasurementUnitAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasurementUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_UNIT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASUREMENT_UNIT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasurementMediumAttribute(
         IntegerAttributeCallback callback) {
-        readMeasurementMediumAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_MEDIUM_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASUREMENT_MEDIUM_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasurementMediumAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasurementMediumAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_MEDIUM_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASUREMENT_MEDIUM_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLevelValueAttribute(
         IntegerAttributeCallback callback) {
-        readLevelValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEVEL_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LEVEL_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLevelValueAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLevelValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEVEL_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LEVEL_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readPeakMeasuredValueAttribute(long chipClusterPtr, PeakMeasuredValueAttributeCallback callback);
-
-    private native void subscribePeakMeasuredValueAttribute(long chipClusterPtr, PeakMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPeakMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribePeakMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageMeasuredValueAttribute(long chipClusterPtr, AverageMeasuredValueAttributeCallback callback);
-
-    private native void subscribeAverageMeasuredValueAttribute(long chipClusterPtr, AverageMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeAverageMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readUncertaintyAttribute(long chipClusterPtr, FloatAttributeCallback callback);
-
-    private native void subscribeUncertaintyAttribute(long chipClusterPtr, FloatAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMeasurementUnitAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMeasurementUnitAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMeasurementMediumAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMeasurementMediumAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLevelValueAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeLevelValueAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class Pm10ConcentrationMeasurementCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1069L;
 
+    private static final long MEASURED_VALUE_ATTRIBUTE_ID = 0L;
+    private static final long MIN_MEASURED_VALUE_ATTRIBUTE_ID = 1L;
+    private static final long MAX_MEASURED_VALUE_ATTRIBUTE_ID = 2L;
+    private static final long PEAK_MEASURED_VALUE_ATTRIBUTE_ID = 3L;
+    private static final long PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID = 4L;
+    private static final long AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID = 5L;
+    private static final long AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID = 6L;
+    private static final long UNCERTAINTY_ATTRIBUTE_ID = 7L;
+    private static final long MEASUREMENT_UNIT_ATTRIBUTE_ID = 8L;
+    private static final long MEASUREMENT_MEDIUM_ATTRIBUTE_ID = 9L;
+    private static final long LEVEL_VALUE_ATTRIBUTE_ID = 10L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public Pm10ConcentrationMeasurementCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface MeasuredValueAttributeCallback {
+    public interface MeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MinMeasuredValueAttributeCallback {
+    public interface MinMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MaxMeasuredValueAttributeCallback {
+    public interface MaxMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface PeakMeasuredValueAttributeCallback {
+    public interface PeakMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AverageMeasuredValueAttributeCallback {
+    public interface AverageMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback) {
-        readMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback) {
-        readMinMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback) {
-        readMaxMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPeakMeasuredValueAttribute(
         PeakMeasuredValueAttributeCallback callback) {
-        readPeakMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PEAK_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribePeakMeasuredValueAttribute(
         PeakMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePeakMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PEAK_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPeakMeasuredValueWindowAttribute(
         LongAttributeCallback callback) {
-        readPeakMeasuredValueWindowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribePeakMeasuredValueWindowAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePeakMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageMeasuredValueAttribute(
         AverageMeasuredValueAttributeCallback callback) {
-        readAverageMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageMeasuredValueAttribute(
         AverageMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageMeasuredValueWindowAttribute(
         LongAttributeCallback callback) {
-        readAverageMeasuredValueWindowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageMeasuredValueWindowAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUncertaintyAttribute(
         FloatAttributeCallback callback) {
-        readUncertaintyAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNCERTAINTY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UNCERTAINTY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeUncertaintyAttribute(
         FloatAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUncertaintyAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNCERTAINTY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UNCERTAINTY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasurementUnitAttribute(
         IntegerAttributeCallback callback) {
-        readMeasurementUnitAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_UNIT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASUREMENT_UNIT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasurementUnitAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasurementUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_UNIT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASUREMENT_UNIT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasurementMediumAttribute(
         IntegerAttributeCallback callback) {
-        readMeasurementMediumAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_MEDIUM_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASUREMENT_MEDIUM_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasurementMediumAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasurementMediumAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_MEDIUM_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASUREMENT_MEDIUM_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLevelValueAttribute(
         IntegerAttributeCallback callback) {
-        readLevelValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEVEL_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LEVEL_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLevelValueAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLevelValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEVEL_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LEVEL_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readPeakMeasuredValueAttribute(long chipClusterPtr, PeakMeasuredValueAttributeCallback callback);
-
-    private native void subscribePeakMeasuredValueAttribute(long chipClusterPtr, PeakMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPeakMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribePeakMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageMeasuredValueAttribute(long chipClusterPtr, AverageMeasuredValueAttributeCallback callback);
-
-    private native void subscribeAverageMeasuredValueAttribute(long chipClusterPtr, AverageMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeAverageMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readUncertaintyAttribute(long chipClusterPtr, FloatAttributeCallback callback);
-
-    private native void subscribeUncertaintyAttribute(long chipClusterPtr, FloatAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMeasurementUnitAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMeasurementUnitAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMeasurementMediumAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMeasurementMediumAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readLevelValueAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeLevelValueAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class TotalVolatileOrganicCompoundsConcentrationMeasurementCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1070L;
 
+    private static final long MEASURED_VALUE_ATTRIBUTE_ID = 0L;
+    private static final long MIN_MEASURED_VALUE_ATTRIBUTE_ID = 1L;
+    private static final long MAX_MEASURED_VALUE_ATTRIBUTE_ID = 2L;
+    private static final long PEAK_MEASURED_VALUE_ATTRIBUTE_ID = 3L;
+    private static final long PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID = 4L;
+    private static final long AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID = 5L;
+    private static final long AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID = 6L;
+    private static final long UNCERTAINTY_ATTRIBUTE_ID = 7L;
+    private static final long MEASUREMENT_UNIT_ATTRIBUTE_ID = 8L;
+    private static final long MEASUREMENT_MEDIUM_ATTRIBUTE_ID = 9L;
+    private static final long LEVEL_VALUE_ATTRIBUTE_ID = 10L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public TotalVolatileOrganicCompoundsConcentrationMeasurementCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface MeasuredValueAttributeCallback {
+    public interface MeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MinMeasuredValueAttributeCallback {
+    public interface MinMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface MaxMeasuredValueAttributeCallback {
+    public interface MaxMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface PeakMeasuredValueAttributeCallback {
+    public interface PeakMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AverageMeasuredValueAttributeCallback {
+    public interface AverageMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback) {
-        readMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback) {
-        readMinMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback) {
-        readMaxMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPeakMeasuredValueAttribute(
         PeakMeasuredValueAttributeCallback callback) {
-        readPeakMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PEAK_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribePeakMeasuredValueAttribute(
         PeakMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePeakMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PEAK_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPeakMeasuredValueWindowAttribute(
         LongAttributeCallback callback) {
-        readPeakMeasuredValueWindowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribePeakMeasuredValueWindowAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePeakMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageMeasuredValueAttribute(
         AverageMeasuredValueAttributeCallback callback) {
-        readAverageMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageMeasuredValueAttribute(
         AverageMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageMeasuredValueWindowAttribute(
         LongAttributeCallback callback) {
-        readAverageMeasuredValueWindowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageMeasuredValueWindowAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUncertaintyAttribute(
         FloatAttributeCallback callback) {
-        readUncertaintyAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNCERTAINTY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UNCERTAINTY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeUncertaintyAttribute(
         FloatAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUncertaintyAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNCERTAINTY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UNCERTAINTY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasurementUnitAttribute(
         IntegerAttributeCallback callback) {
-        readMeasurementUnitAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_UNIT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASUREMENT_UNIT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasurementUnitAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasurementUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_UNIT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASUREMENT_UNIT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasurementMediumAttribute(
         IntegerAttributeCallback callback) {
-        readMeasurementMediumAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_MEDIUM_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASUREMENT_MEDIUM_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasurementMediumAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasurementMediumAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_MEDIUM_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASUREMENT_MEDIUM_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLevelValueAttribute(
         IntegerAttributeCallback callback) {
-        readLevelValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEVEL_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LEVEL_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLevelValueAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLevelValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEVEL_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LEVEL_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readMeasuredValueAttribute(long chipClusterPtr, MeasuredValueAttributeCallback callback);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
+  }
 
-    private native void subscribeMeasuredValueAttribute(long chipClusterPtr, MeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
+  public static class RadonConcentrationMeasurementCluster extends BaseChipCluster {
+    public static final long CLUSTER_ID = 1071L;
 
-    private native void readMinMeasuredValueAttribute(long chipClusterPtr, MinMeasuredValueAttributeCallback callback);
+    private static final long MEASURED_VALUE_ATTRIBUTE_ID = 0L;
+    private static final long MIN_MEASURED_VALUE_ATTRIBUTE_ID = 1L;
+    private static final long MAX_MEASURED_VALUE_ATTRIBUTE_ID = 2L;
+    private static final long PEAK_MEASURED_VALUE_ATTRIBUTE_ID = 3L;
+    private static final long PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID = 4L;
+    private static final long AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID = 5L;
+    private static final long AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID = 6L;
+    private static final long UNCERTAINTY_ATTRIBUTE_ID = 7L;
+    private static final long MEASUREMENT_UNIT_ATTRIBUTE_ID = 8L;
+    private static final long MEASUREMENT_MEDIUM_ATTRIBUTE_ID = 9L;
+    private static final long LEVEL_VALUE_ATTRIBUTE_ID = 10L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
 
-    private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
+    public RadonConcentrationMeasurementCluster(long devicePtr, int endpointId) {
+      super(devicePtr, endpointId, CLUSTER_ID);
+    }
 
-    private native void readMaxMeasuredValueAttribute(long chipClusterPtr, MaxMeasuredValueAttributeCallback callback);
+    @Override
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
+    public interface MeasuredValueAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Float value);
+    }
 
-    private native void readPeakMeasuredValueAttribute(long chipClusterPtr, PeakMeasuredValueAttributeCallback callback);
+    public interface MinMeasuredValueAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Float value);
+    }
 
-    private native void subscribePeakMeasuredValueAttribute(long chipClusterPtr, PeakMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
+    public interface MaxMeasuredValueAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Float value);
+    }
 
-    private native void readPeakMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribePeakMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageMeasuredValueAttribute(long chipClusterPtr, AverageMeasuredValueAttributeCallback callback);
-
-    private native void subscribeAverageMeasuredValueAttribute(long chipClusterPtr, AverageMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeAverageMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readUncertaintyAttribute(long chipClusterPtr, FloatAttributeCallback callback);
-
-    private native void subscribeUncertaintyAttribute(long chipClusterPtr, FloatAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMeasurementUnitAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMeasurementUnitAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMeasurementMediumAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMeasurementMediumAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLevelValueAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeLevelValueAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-  }
-
-  public static class RadonConcentrationMeasurementCluster extends BaseChipCluster {
-    public static final long CLUSTER_ID = 1071L;
-
-    public RadonConcentrationMeasurementCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
-    }
-
-    @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
-
-    public interface MeasuredValueAttributeCallback {
-      void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface MinMeasuredValueAttributeCallback {
-      void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface MaxMeasuredValueAttributeCallback {
-      void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface PeakMeasuredValueAttributeCallback {
+    public interface PeakMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AverageMeasuredValueAttributeCallback {
+    public interface AverageMeasuredValueAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback) {
-        readMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasuredValueAttribute(
         MeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback) {
-        readMinMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMinMeasuredValueAttribute(
         MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MIN_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MIN_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback) {
-        readMaxMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMaxMeasuredValueAttribute(
         MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAX_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MAX_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPeakMeasuredValueAttribute(
         PeakMeasuredValueAttributeCallback callback) {
-        readPeakMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PEAK_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribePeakMeasuredValueAttribute(
         PeakMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePeakMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PEAK_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPeakMeasuredValueWindowAttribute(
         LongAttributeCallback callback) {
-        readPeakMeasuredValueWindowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribePeakMeasuredValueWindowAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePeakMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PEAK_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageMeasuredValueAttribute(
         AverageMeasuredValueAttributeCallback callback) {
-        readAverageMeasuredValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageMeasuredValueAttribute(
         AverageMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_MEASURED_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageMeasuredValueWindowAttribute(
         LongAttributeCallback callback) {
-        readAverageMeasuredValueWindowAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageMeasuredValueWindowAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageMeasuredValueWindowAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_MEASURED_VALUE_WINDOW_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readUncertaintyAttribute(
         FloatAttributeCallback callback) {
-        readUncertaintyAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNCERTAINTY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UNCERTAINTY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeUncertaintyAttribute(
         FloatAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUncertaintyAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNCERTAINTY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UNCERTAINTY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasurementUnitAttribute(
         IntegerAttributeCallback callback) {
-        readMeasurementUnitAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_UNIT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASUREMENT_UNIT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasurementUnitAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasurementUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_UNIT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASUREMENT_UNIT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasurementMediumAttribute(
         IntegerAttributeCallback callback) {
-        readMeasurementMediumAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_MEDIUM_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASUREMENT_MEDIUM_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasurementMediumAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasurementMediumAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_MEDIUM_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASUREMENT_MEDIUM_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLevelValueAttribute(
         IntegerAttributeCallback callback) {
-        readLevelValueAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEVEL_VALUE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LEVEL_VALUE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLevelValueAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLevelValueAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LEVEL_VALUE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LEVEL_VALUE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readPeakMeasuredValueAttribute(long chipClusterPtr, PeakMeasuredValueAttributeCallback callback);
-
-    private native void subscribePeakMeasuredValueAttribute(long chipClusterPtr, PeakMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPeakMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribePeakMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageMeasuredValueAttribute(long chipClusterPtr, AverageMeasuredValueAttributeCallback callback);
-
-    private native void subscribeAverageMeasuredValueAttribute(long chipClusterPtr, AverageMeasuredValueAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeAverageMeasuredValueWindowAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readUncertaintyAttribute(long chipClusterPtr, FloatAttributeCallback callback);
-
-    private native void subscribeUncertaintyAttribute(long chipClusterPtr, FloatAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readMeasurementUnitAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMeasurementUnitAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readMeasurementMediumAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeMeasurementMediumAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLevelValueAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeLevelValueAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class WakeOnLanCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1283L;
 
+    private static final long M_A_C_ADDRESS_ATTRIBUTE_ID = 0L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public WakeOnLanCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readMACAddressAttribute(
         CharStringAttributeCallback callback) {
-        readMACAddressAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, M_A_C_ADDRESS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, M_A_C_ADDRESS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMACAddressAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMACAddressAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, M_A_C_ADDRESS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, M_A_C_ADDRESS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readMACAddressAttribute(long chipClusterPtr, CharStringAttributeCallback callback);
-
-    private native void subscribeMACAddressAttribute(long chipClusterPtr, CharStringAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class ChannelCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1284L;
 
+    private static final long CHANNEL_LIST_ATTRIBUTE_ID = 0L;
+    private static final long LINEUP_ATTRIBUTE_ID = 1L;
+    private static final long CURRENT_CHANNEL_ATTRIBUTE_ID = 2L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public ChannelCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void changeChannel(ChangeChannelResponseCallback callback, String match) {
-      changeChannel(chipClusterPtr, callback, match, null);
+      changeChannel(callback, match, 0);
     }
 
     public void changeChannel(ChangeChannelResponseCallback callback, String match, int timedInvokeTimeoutMs) {
-      changeChannel(chipClusterPtr, callback, match, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long matchFieldID = 0L;
+      BaseTLVType matchtlvValue = new StringType(match);
+      elements.add(new StructElement(matchFieldID, matchtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long dataFieldID = 1L;
+          Optional<String> data = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == dataFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                data = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(status, data);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void changeChannelByNumber(DefaultClusterCallback callback, Integer majorNumber, Integer minorNumber) {
-      changeChannelByNumber(chipClusterPtr, callback, majorNumber, minorNumber, null);
+      changeChannelByNumber(callback, majorNumber, minorNumber, 0);
     }
 
     public void changeChannelByNumber(DefaultClusterCallback callback, Integer majorNumber, Integer minorNumber, int timedInvokeTimeoutMs) {
-      changeChannelByNumber(chipClusterPtr, callback, majorNumber, minorNumber, timedInvokeTimeoutMs);
+      final long commandId = 2L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long majorNumberFieldID = 0L;
+      BaseTLVType majorNumbertlvValue = new UIntType(majorNumber);
+      elements.add(new StructElement(majorNumberFieldID, majorNumbertlvValue));
+
+      final long minorNumberFieldID = 1L;
+      BaseTLVType minorNumbertlvValue = new UIntType(minorNumber);
+      elements.add(new StructElement(minorNumberFieldID, minorNumbertlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void skipChannel(DefaultClusterCallback callback, Integer count) {
-      skipChannel(chipClusterPtr, callback, count, null);
+      skipChannel(callback, count, 0);
     }
 
     public void skipChannel(DefaultClusterCallback callback, Integer count, int timedInvokeTimeoutMs) {
-      skipChannel(chipClusterPtr, callback, count, timedInvokeTimeoutMs);
-    }
+      final long commandId = 3L;
 
-    private native void changeChannel(long chipClusterPtr, ChangeChannelResponseCallback callback, String match, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long countFieldID = 0L;
+      BaseTLVType counttlvValue = new IntType(count);
+      elements.add(new StructElement(countFieldID, counttlvValue));
 
-    private native void changeChannelByNumber(long chipClusterPtr, DefaultClusterCallback callback, Integer majorNumber, Integer minorNumber, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void skipChannel(long chipClusterPtr, DefaultClusterCallback callback, Integer count, @Nullable Integer timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface ChangeChannelResponseCallback {
+    public interface ChangeChannelResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, Optional<String> data);
-      void onError(Exception error);
     }
 
-    public interface ChannelListAttributeCallback {
+    public interface ChannelListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.ChannelClusterChannelInfoStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface LineupAttributeCallback {
+    public interface LineupAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable ChipStructs.ChannelClusterLineupInfoStruct value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface CurrentChannelAttributeCallback {
+    public interface CurrentChannelAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable ChipStructs.ChannelClusterChannelInfoStruct value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readChannelListAttribute(
         ChannelListAttributeCallback callback) {
-        readChannelListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CHANNEL_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.ChannelClusterChannelInfoStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CHANNEL_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeChannelListAttribute(
         ChannelListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeChannelListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CHANNEL_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.ChannelClusterChannelInfoStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CHANNEL_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLineupAttribute(
         LineupAttributeCallback callback) {
-        readLineupAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LINEUP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable ChipStructs.ChannelClusterLineupInfoStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LINEUP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLineupAttribute(
         LineupAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLineupAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LINEUP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable ChipStructs.ChannelClusterLineupInfoStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LINEUP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentChannelAttribute(
         CurrentChannelAttributeCallback callback) {
-        readCurrentChannelAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_CHANNEL_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable ChipStructs.ChannelClusterChannelInfoStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_CHANNEL_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentChannelAttribute(
         CurrentChannelAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentChannelAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_CHANNEL_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable ChipStructs.ChannelClusterChannelInfoStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_CHANNEL_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readLineupAttribute(long chipClusterPtr, LineupAttributeCallback callback);
-
-    private native void subscribeLineupAttribute(long chipClusterPtr, LineupAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readCurrentChannelAttribute(long chipClusterPtr, CurrentChannelAttributeCallback callback);
-
-    private native void subscribeCurrentChannelAttribute(long chipClusterPtr, CurrentChannelAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class TargetNavigatorCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1285L;
 
+    private static final long TARGET_LIST_ATTRIBUTE_ID = 0L;
+    private static final long CURRENT_TARGET_ATTRIBUTE_ID = 1L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public TargetNavigatorCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void navigateTarget(NavigateTargetResponseCallback callback, Integer target, Optional<String> data) {
-      navigateTarget(chipClusterPtr, callback, target, data, null);
+      navigateTarget(callback, target, data, 0);
     }
 
     public void navigateTarget(NavigateTargetResponseCallback callback, Integer target, Optional<String> data, int timedInvokeTimeoutMs) {
-      navigateTarget(chipClusterPtr, callback, target, data, timedInvokeTimeoutMs);
-    }
-
-    private native void navigateTarget(long chipClusterPtr, NavigateTargetResponseCallback callback, Integer target, Optional<String> data, @Nullable Integer timedInvokeTimeoutMs);
-
-    public interface NavigateTargetResponseCallback {
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long targetFieldID = 0L;
+      BaseTLVType targettlvValue = new UIntType(target);
+      elements.add(new StructElement(targetFieldID, targettlvValue));
+
+      final long dataFieldID = 1L;
+      BaseTLVType datatlvValue = data.<BaseTLVType>map((nonOptionaldata) -> new StringType(nonOptionaldata)).orElse(new EmptyType());
+      elements.add(new StructElement(dataFieldID, datatlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long dataFieldID = 1L;
+          Optional<String> data = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == dataFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                data = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(status, data);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface NavigateTargetResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, Optional<String> data);
-      void onError(Exception error);
     }
 
-    public interface TargetListAttributeCallback {
+    public interface TargetListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.TargetNavigatorClusterTargetInfoStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readTargetListAttribute(
         TargetListAttributeCallback callback) {
-        readTargetListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TARGET_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.TargetNavigatorClusterTargetInfoStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TARGET_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTargetListAttribute(
         TargetListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTargetListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TARGET_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.TargetNavigatorClusterTargetInfoStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TARGET_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentTargetAttribute(
         IntegerAttributeCallback callback) {
-        readCurrentTargetAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_TARGET_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_TARGET_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentTargetAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentTargetAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_TARGET_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_TARGET_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readTargetListAttribute(long chipClusterPtr, TargetListAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeTargetListAttribute(long chipClusterPtr, TargetListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readCurrentTargetAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeCurrentTargetAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class MediaPlaybackCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1286L;
 
+    private static final long CURRENT_STATE_ATTRIBUTE_ID = 0L;
+    private static final long START_TIME_ATTRIBUTE_ID = 1L;
+    private static final long DURATION_ATTRIBUTE_ID = 2L;
+    private static final long SAMPLED_POSITION_ATTRIBUTE_ID = 3L;
+    private static final long PLAYBACK_SPEED_ATTRIBUTE_ID = 4L;
+    private static final long SEEK_RANGE_END_ATTRIBUTE_ID = 5L;
+    private static final long SEEK_RANGE_START_ATTRIBUTE_ID = 6L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public MediaPlaybackCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void play(PlaybackResponseCallback callback) {
-      play(chipClusterPtr, callback, null);
+      play(callback, 0);
     }
 
     public void play(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) {
-      play(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long dataFieldID = 1L;
+          Optional<String> data = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == dataFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                data = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(status, data);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void pause(PlaybackResponseCallback callback) {
-      pause(chipClusterPtr, callback, null);
+      pause(callback, 0);
     }
 
     public void pause(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) {
-      pause(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 1L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long dataFieldID = 1L;
+          Optional<String> data = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == dataFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                data = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(status, data);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void stop(PlaybackResponseCallback callback) {
-      stop(chipClusterPtr, callback, null);
+      stop(callback, 0);
     }
 
     public void stop(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) {
-      stop(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 2L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long dataFieldID = 1L;
+          Optional<String> data = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == dataFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                data = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(status, data);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void startOver(PlaybackResponseCallback callback) {
-      startOver(chipClusterPtr, callback, null);
+      startOver(callback, 0);
     }
 
     public void startOver(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) {
-      startOver(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 3L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long dataFieldID = 1L;
+          Optional<String> data = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == dataFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                data = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(status, data);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void previous(PlaybackResponseCallback callback) {
-      previous(chipClusterPtr, callback, null);
+      previous(callback, 0);
     }
 
     public void previous(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) {
-      previous(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 4L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long dataFieldID = 1L;
+          Optional<String> data = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == dataFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                data = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(status, data);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void next(PlaybackResponseCallback callback) {
-      next(chipClusterPtr, callback, null);
+      next(callback, 0);
     }
 
     public void next(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) {
-      next(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 5L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long dataFieldID = 1L;
+          Optional<String> data = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == dataFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                data = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(status, data);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void rewind(PlaybackResponseCallback callback) {
-      rewind(chipClusterPtr, callback, null);
+      rewind(callback, 0);
     }
 
     public void rewind(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) {
-      rewind(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 6L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long dataFieldID = 1L;
+          Optional<String> data = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == dataFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                data = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(status, data);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void fastForward(PlaybackResponseCallback callback) {
-      fastForward(chipClusterPtr, callback, null);
+      fastForward(callback, 0);
     }
 
     public void fastForward(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) {
-      fastForward(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 7L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long dataFieldID = 1L;
+          Optional<String> data = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == dataFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                data = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(status, data);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void skipForward(PlaybackResponseCallback callback, Long deltaPositionMilliseconds) {
-      skipForward(chipClusterPtr, callback, deltaPositionMilliseconds, null);
+      skipForward(callback, deltaPositionMilliseconds, 0);
     }
 
     public void skipForward(PlaybackResponseCallback callback, Long deltaPositionMilliseconds, int timedInvokeTimeoutMs) {
-      skipForward(chipClusterPtr, callback, deltaPositionMilliseconds, timedInvokeTimeoutMs);
+      final long commandId = 8L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long deltaPositionMillisecondsFieldID = 0L;
+      BaseTLVType deltaPositionMillisecondstlvValue = new UIntType(deltaPositionMilliseconds);
+      elements.add(new StructElement(deltaPositionMillisecondsFieldID, deltaPositionMillisecondstlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long dataFieldID = 1L;
+          Optional<String> data = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == dataFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                data = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(status, data);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void skipBackward(PlaybackResponseCallback callback, Long deltaPositionMilliseconds) {
-      skipBackward(chipClusterPtr, callback, deltaPositionMilliseconds, null);
+      skipBackward(callback, deltaPositionMilliseconds, 0);
     }
 
     public void skipBackward(PlaybackResponseCallback callback, Long deltaPositionMilliseconds, int timedInvokeTimeoutMs) {
-      skipBackward(chipClusterPtr, callback, deltaPositionMilliseconds, timedInvokeTimeoutMs);
+      final long commandId = 9L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long deltaPositionMillisecondsFieldID = 0L;
+      BaseTLVType deltaPositionMillisecondstlvValue = new UIntType(deltaPositionMilliseconds);
+      elements.add(new StructElement(deltaPositionMillisecondsFieldID, deltaPositionMillisecondstlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long dataFieldID = 1L;
+          Optional<String> data = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == dataFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                data = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(status, data);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void seek(PlaybackResponseCallback callback, Long position) {
-      seek(chipClusterPtr, callback, position, null);
+      seek(callback, position, 0);
     }
 
     public void seek(PlaybackResponseCallback callback, Long position, int timedInvokeTimeoutMs) {
-      seek(chipClusterPtr, callback, position, timedInvokeTimeoutMs);
-    }
-
-    private native void play(long chipClusterPtr, PlaybackResponseCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void pause(long chipClusterPtr, PlaybackResponseCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void stop(long chipClusterPtr, PlaybackResponseCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void startOver(long chipClusterPtr, PlaybackResponseCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void previous(long chipClusterPtr, PlaybackResponseCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void next(long chipClusterPtr, PlaybackResponseCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void rewind(long chipClusterPtr, PlaybackResponseCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void fastForward(long chipClusterPtr, PlaybackResponseCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void skipForward(long chipClusterPtr, PlaybackResponseCallback callback, Long deltaPositionMilliseconds, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void skipBackward(long chipClusterPtr, PlaybackResponseCallback callback, Long deltaPositionMilliseconds, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void seek(long chipClusterPtr, PlaybackResponseCallback callback, Long position, @Nullable Integer timedInvokeTimeoutMs);
-
-    public interface PlaybackResponseCallback {
+      final long commandId = 11L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long positionFieldID = 0L;
+      BaseTLVType positiontlvValue = new UIntType(position);
+      elements.add(new StructElement(positionFieldID, positiontlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long dataFieldID = 1L;
+          Optional<String> data = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == dataFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                data = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(status, data);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface PlaybackResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, Optional<String> data);
-      void onError(Exception error);
     }
 
-    public interface StartTimeAttributeCallback {
+    public interface StartTimeAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface DurationAttributeCallback {
+    public interface DurationAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface SampledPositionAttributeCallback {
+    public interface SampledPositionAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable ChipStructs.MediaPlaybackClusterPlaybackPositionStruct value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface SeekRangeEndAttributeCallback {
+    public interface SeekRangeEndAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface SeekRangeStartAttributeCallback {
+    public interface SeekRangeStartAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readCurrentStateAttribute(
         IntegerAttributeCallback callback) {
-        readCurrentStateAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_STATE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_STATE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentStateAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentStateAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_STATE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_STATE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readStartTimeAttribute(
         StartTimeAttributeCallback callback) {
-        readStartTimeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, START_TIME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, START_TIME_ATTRIBUTE_ID, true);
     }
 
     public void subscribeStartTimeAttribute(
         StartTimeAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeStartTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, START_TIME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, START_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDurationAttribute(
         DurationAttributeCallback callback) {
-        readDurationAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DURATION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DURATION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDurationAttribute(
         DurationAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDurationAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DURATION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DURATION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSampledPositionAttribute(
         SampledPositionAttributeCallback callback) {
-        readSampledPositionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SAMPLED_POSITION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable ChipStructs.MediaPlaybackClusterPlaybackPositionStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SAMPLED_POSITION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSampledPositionAttribute(
         SampledPositionAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSampledPositionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SAMPLED_POSITION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable ChipStructs.MediaPlaybackClusterPlaybackPositionStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SAMPLED_POSITION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPlaybackSpeedAttribute(
         FloatAttributeCallback callback) {
-        readPlaybackSpeedAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PLAYBACK_SPEED_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PLAYBACK_SPEED_ATTRIBUTE_ID, true);
     }
 
     public void subscribePlaybackSpeedAttribute(
         FloatAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePlaybackSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PLAYBACK_SPEED_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PLAYBACK_SPEED_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSeekRangeEndAttribute(
         SeekRangeEndAttributeCallback callback) {
-        readSeekRangeEndAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SEEK_RANGE_END_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SEEK_RANGE_END_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSeekRangeEndAttribute(
         SeekRangeEndAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSeekRangeEndAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SEEK_RANGE_END_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SEEK_RANGE_END_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSeekRangeStartAttribute(
         SeekRangeStartAttributeCallback callback) {
-        readSeekRangeStartAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SEEK_RANGE_START_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SEEK_RANGE_START_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSeekRangeStartAttribute(
         SeekRangeStartAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSeekRangeStartAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SEEK_RANGE_START_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SEEK_RANGE_START_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readCurrentStateAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeCurrentStateAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readStartTimeAttribute(long chipClusterPtr, StartTimeAttributeCallback callback);
-
-    private native void subscribeStartTimeAttribute(long chipClusterPtr, StartTimeAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readDurationAttribute(long chipClusterPtr, DurationAttributeCallback callback);
-
-    private native void subscribeDurationAttribute(long chipClusterPtr, DurationAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSampledPositionAttribute(long chipClusterPtr, SampledPositionAttributeCallback callback);
-
-    private native void subscribeSampledPositionAttribute(long chipClusterPtr, SampledPositionAttributeCallback 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, SeekRangeEndAttributeCallback callback);
-
-    private native void subscribeSeekRangeEndAttribute(long chipClusterPtr, SeekRangeEndAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSeekRangeStartAttribute(long chipClusterPtr, SeekRangeStartAttributeCallback callback);
-
-    private native void subscribeSeekRangeStartAttribute(long chipClusterPtr, SeekRangeStartAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class MediaInputCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1287L;
 
+    private static final long INPUT_LIST_ATTRIBUTE_ID = 0L;
+    private static final long CURRENT_INPUT_ATTRIBUTE_ID = 1L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public MediaInputCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void selectInput(DefaultClusterCallback callback, Integer index) {
-      selectInput(chipClusterPtr, callback, index, null);
+      selectInput(callback, index, 0);
     }
 
     public void selectInput(DefaultClusterCallback callback, Integer index, int timedInvokeTimeoutMs) {
-      selectInput(chipClusterPtr, callback, index, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long indexFieldID = 0L;
+      BaseTLVType indextlvValue = new UIntType(index);
+      elements.add(new StructElement(indexFieldID, indextlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void showInputStatus(DefaultClusterCallback callback) {
-      showInputStatus(chipClusterPtr, callback, null);
+      showInputStatus(callback, 0);
     }
 
     public void showInputStatus(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      showInputStatus(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 1L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void hideInputStatus(DefaultClusterCallback callback) {
-      hideInputStatus(chipClusterPtr, callback, null);
+      hideInputStatus(callback, 0);
     }
 
     public void hideInputStatus(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      hideInputStatus(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 2L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void renameInput(DefaultClusterCallback callback, Integer index, String name) {
-      renameInput(chipClusterPtr, callback, index, name, null);
+      renameInput(callback, index, name, 0);
     }
 
     public void renameInput(DefaultClusterCallback callback, Integer index, String name, int timedInvokeTimeoutMs) {
-      renameInput(chipClusterPtr, callback, index, name, timedInvokeTimeoutMs);
-    }
-
-    private native void selectInput(long chipClusterPtr, DefaultClusterCallback callback, Integer index, @Nullable Integer timedInvokeTimeoutMs);
+      final long commandId = 3L;
 
-    private native void showInputStatus(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long indexFieldID = 0L;
+      BaseTLVType indextlvValue = new UIntType(index);
+      elements.add(new StructElement(indexFieldID, indextlvValue));
 
-    private native void hideInputStatus(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
+      final long nameFieldID = 1L;
+      BaseTLVType nametlvValue = new StringType(name);
+      elements.add(new StructElement(nameFieldID, nametlvValue));
 
-    private native void renameInput(long chipClusterPtr, DefaultClusterCallback callback, Integer index, String name, @Nullable Integer timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface InputListAttributeCallback {
+    public interface InputListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.MediaInputClusterInputInfoStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readInputListAttribute(
         InputListAttributeCallback callback) {
-        readInputListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INPUT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.MediaInputClusterInputInfoStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INPUT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeInputListAttribute(
         InputListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInputListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INPUT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.MediaInputClusterInputInfoStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INPUT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentInputAttribute(
         IntegerAttributeCallback callback) {
-        readCurrentInputAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_INPUT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_INPUT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentInputAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentInputAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_INPUT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_INPUT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readInputListAttribute(long chipClusterPtr, InputListAttributeCallback callback);
-
-    private native void subscribeInputListAttribute(long chipClusterPtr, InputListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readCurrentInputAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeCurrentInputAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class LowPowerCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1288L;
 
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public LowPowerCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void sleep(DefaultClusterCallback callback) {
-      sleep(chipClusterPtr, callback, null);
+      sleep(callback, 0);
     }
 
     public void sleep(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      sleep(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
+      final long commandId = 0L;
 
-    private native void sleep(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class KeypadInputCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1289L;
 
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public KeypadInputCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void sendKey(SendKeyResponseCallback callback, Integer keyCode) {
-      sendKey(chipClusterPtr, callback, keyCode, null);
+      sendKey(callback, keyCode, 0);
     }
 
     public void sendKey(SendKeyResponseCallback callback, Integer keyCode, int timedInvokeTimeoutMs) {
-      sendKey(chipClusterPtr, callback, keyCode, timedInvokeTimeoutMs);
-    }
-
-    private native void sendKey(long chipClusterPtr, SendKeyResponseCallback callback, Integer keyCode, @Nullable Integer timedInvokeTimeoutMs);
-
-    public interface SendKeyResponseCallback {
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long keyCodeFieldID = 0L;
+      BaseTLVType keyCodetlvValue = new UIntType(keyCode);
+      elements.add(new StructElement(keyCodeFieldID, keyCodetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            }
+          }
+          callback.onSuccess(status);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface SendKeyResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status);
-      void onError(Exception error);
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    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);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class ContentLauncherCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1290L;
 
+    private static final long ACCEPT_HEADER_ATTRIBUTE_ID = 0L;
+    private static final long SUPPORTED_STREAMING_PROTOCOLS_ATTRIBUTE_ID = 1L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public ContentLauncherCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void launchContent(LauncherResponseCallback callback, ChipStructs.ContentLauncherClusterContentSearchStruct search, Boolean autoPlay, Optional<String> data) {
-      launchContent(chipClusterPtr, callback, search, autoPlay, data, null);
+      launchContent(callback, search, autoPlay, data, 0);
     }
 
     public void launchContent(LauncherResponseCallback callback, ChipStructs.ContentLauncherClusterContentSearchStruct search, Boolean autoPlay, Optional<String> data, int timedInvokeTimeoutMs) {
-      launchContent(chipClusterPtr, callback, search, autoPlay, data, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long searchFieldID = 0L;
+      BaseTLVType searchtlvValue = search.encodeTlv();
+      elements.add(new StructElement(searchFieldID, searchtlvValue));
+
+      final long autoPlayFieldID = 1L;
+      BaseTLVType autoPlaytlvValue = new BooleanType(autoPlay);
+      elements.add(new StructElement(autoPlayFieldID, autoPlaytlvValue));
+
+      final long dataFieldID = 2L;
+      BaseTLVType datatlvValue = data.<BaseTLVType>map((nonOptionaldata) -> new StringType(nonOptionaldata)).orElse(new EmptyType());
+      elements.add(new StructElement(dataFieldID, datatlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long dataFieldID = 1L;
+          Optional<String> data = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == dataFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                data = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(status, data);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void launchURL(LauncherResponseCallback callback, String contentURL, Optional<String> displayString, Optional<ChipStructs.ContentLauncherClusterBrandingInformationStruct> brandingInformation) {
-      launchURL(chipClusterPtr, callback, contentURL, displayString, brandingInformation, null);
+      launchURL(callback, contentURL, displayString, brandingInformation, 0);
     }
 
     public void launchURL(LauncherResponseCallback callback, String contentURL, Optional<String> displayString, Optional<ChipStructs.ContentLauncherClusterBrandingInformationStruct> brandingInformation, int timedInvokeTimeoutMs) {
-      launchURL(chipClusterPtr, callback, contentURL, displayString, brandingInformation, timedInvokeTimeoutMs);
-    }
-
-    private native void launchContent(long chipClusterPtr, LauncherResponseCallback callback, ChipStructs.ContentLauncherClusterContentSearchStruct search, Boolean autoPlay, Optional<String> data, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void launchURL(long chipClusterPtr, LauncherResponseCallback callback, String contentURL, Optional<String> displayString, Optional<ChipStructs.ContentLauncherClusterBrandingInformationStruct> brandingInformation, @Nullable Integer timedInvokeTimeoutMs);
-
-    public interface LauncherResponseCallback {
+      final long commandId = 1L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long contentURLFieldID = 0L;
+      BaseTLVType contentURLtlvValue = new StringType(contentURL);
+      elements.add(new StructElement(contentURLFieldID, contentURLtlvValue));
+
+      final long displayStringFieldID = 1L;
+      BaseTLVType displayStringtlvValue = displayString.<BaseTLVType>map((nonOptionaldisplayString) -> new StringType(nonOptionaldisplayString)).orElse(new EmptyType());
+      elements.add(new StructElement(displayStringFieldID, displayStringtlvValue));
+
+      final long brandingInformationFieldID = 2L;
+      BaseTLVType brandingInformationtlvValue = brandingInformation.<BaseTLVType>map((nonOptionalbrandingInformation) -> nonOptionalbrandingInformation.encodeTlv()).orElse(new EmptyType());
+      elements.add(new StructElement(brandingInformationFieldID, brandingInformationtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long dataFieldID = 1L;
+          Optional<String> data = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == dataFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                data = Optional.of(castingValue.value(String.class));
+              }
+            }
+          }
+          callback.onSuccess(status, data);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface LauncherResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, Optional<String> data);
-      void onError(Exception error);
     }
 
-    public interface AcceptHeaderAttributeCallback {
+    public interface AcceptHeaderAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<String> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readAcceptHeaderAttribute(
         AcceptHeaderAttributeCallback callback) {
-        readAcceptHeaderAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPT_HEADER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<String> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPT_HEADER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptHeaderAttribute(
         AcceptHeaderAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptHeaderAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPT_HEADER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<String> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPT_HEADER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readSupportedStreamingProtocolsAttribute(
         LongAttributeCallback callback) {
-        readSupportedStreamingProtocolsAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_STREAMING_PROTOCOLS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, SUPPORTED_STREAMING_PROTOCOLS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeSupportedStreamingProtocolsAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPORTED_STREAMING_PROTOCOLS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, SUPPORTED_STREAMING_PROTOCOLS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readAcceptHeaderAttribute(long chipClusterPtr, AcceptHeaderAttributeCallback callback);
-
-    private native void subscribeAcceptHeaderAttribute(long chipClusterPtr, AcceptHeaderAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readSupportedStreamingProtocolsAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeSupportedStreamingProtocolsAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class AudioOutputCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1291L;
 
+    private static final long OUTPUT_LIST_ATTRIBUTE_ID = 0L;
+    private static final long CURRENT_OUTPUT_ATTRIBUTE_ID = 1L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public AudioOutputCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void selectOutput(DefaultClusterCallback callback, Integer index) {
-      selectOutput(chipClusterPtr, callback, index, null);
+      selectOutput(callback, index, 0);
     }
 
     public void selectOutput(DefaultClusterCallback callback, Integer index, int timedInvokeTimeoutMs) {
-      selectOutput(chipClusterPtr, callback, index, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long indexFieldID = 0L;
+      BaseTLVType indextlvValue = new UIntType(index);
+      elements.add(new StructElement(indexFieldID, indextlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void renameOutput(DefaultClusterCallback callback, Integer index, String name) {
-      renameOutput(chipClusterPtr, callback, index, name, null);
+      renameOutput(callback, index, name, 0);
     }
 
     public void renameOutput(DefaultClusterCallback callback, Integer index, String name, int timedInvokeTimeoutMs) {
-      renameOutput(chipClusterPtr, callback, index, name, timedInvokeTimeoutMs);
-    }
+      final long commandId = 1L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long indexFieldID = 0L;
+      BaseTLVType indextlvValue = new UIntType(index);
+      elements.add(new StructElement(indexFieldID, indextlvValue));
 
-    private native void selectOutput(long chipClusterPtr, DefaultClusterCallback callback, Integer index, @Nullable Integer timedInvokeTimeoutMs);
+      final long nameFieldID = 1L;
+      BaseTLVType nametlvValue = new StringType(name);
+      elements.add(new StructElement(nameFieldID, nametlvValue));
 
-    private native void renameOutput(long chipClusterPtr, DefaultClusterCallback callback, Integer index, String name, @Nullable Integer timedInvokeTimeoutMs);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface OutputListAttributeCallback {
+    public interface OutputListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<ChipStructs.AudioOutputClusterOutputInfoStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readOutputListAttribute(
         OutputListAttributeCallback callback) {
-        readOutputListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OUTPUT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.AudioOutputClusterOutputInfoStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OUTPUT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeOutputListAttribute(
         OutputListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOutputListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OUTPUT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.AudioOutputClusterOutputInfoStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OUTPUT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentOutputAttribute(
         IntegerAttributeCallback callback) {
-        readCurrentOutputAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_OUTPUT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_OUTPUT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentOutputAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentOutputAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_OUTPUT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_OUTPUT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readOutputListAttribute(long chipClusterPtr, OutputListAttributeCallback callback);
-
-    private native void subscribeOutputListAttribute(long chipClusterPtr, OutputListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readCurrentOutputAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeCurrentOutputAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class ApplicationLauncherCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1292L;
 
+    private static final long CATALOG_LIST_ATTRIBUTE_ID = 0L;
+    private static final long CURRENT_APP_ATTRIBUTE_ID = 1L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public ApplicationLauncherCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void launchApp(LauncherResponseCallback callback, Optional<ChipStructs.ApplicationLauncherClusterApplicationStruct> application, Optional<byte[]> data) {
-      launchApp(chipClusterPtr, callback, application, data, null);
+      launchApp(callback, application, data, 0);
     }
 
     public void launchApp(LauncherResponseCallback callback, Optional<ChipStructs.ApplicationLauncherClusterApplicationStruct> application, Optional<byte[]> data, int timedInvokeTimeoutMs) {
-      launchApp(chipClusterPtr, callback, application, data, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long applicationFieldID = 0L;
+      BaseTLVType applicationtlvValue = application.<BaseTLVType>map((nonOptionalapplication) -> nonOptionalapplication.encodeTlv()).orElse(new EmptyType());
+      elements.add(new StructElement(applicationFieldID, applicationtlvValue));
+
+      final long dataFieldID = 1L;
+      BaseTLVType datatlvValue = data.<BaseTLVType>map((nonOptionaldata) -> new ByteArrayType(nonOptionaldata)).orElse(new EmptyType());
+      elements.add(new StructElement(dataFieldID, datatlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long dataFieldID = 1L;
+          Optional<byte[]> data = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == dataFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+                ByteArrayType castingValue = element.value(ByteArrayType.class);
+                data = Optional.of(castingValue.value(byte[].class));
+              }
+            }
+          }
+          callback.onSuccess(status, data);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void stopApp(LauncherResponseCallback callback, Optional<ChipStructs.ApplicationLauncherClusterApplicationStruct> application) {
-      stopApp(chipClusterPtr, callback, application, null);
+      stopApp(callback, application, 0);
     }
 
     public void stopApp(LauncherResponseCallback callback, Optional<ChipStructs.ApplicationLauncherClusterApplicationStruct> application, int timedInvokeTimeoutMs) {
-      stopApp(chipClusterPtr, callback, application, timedInvokeTimeoutMs);
+      final long commandId = 1L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long applicationFieldID = 0L;
+      BaseTLVType applicationtlvValue = application.<BaseTLVType>map((nonOptionalapplication) -> nonOptionalapplication.encodeTlv()).orElse(new EmptyType());
+      elements.add(new StructElement(applicationFieldID, applicationtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long dataFieldID = 1L;
+          Optional<byte[]> data = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == dataFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+                ByteArrayType castingValue = element.value(ByteArrayType.class);
+                data = Optional.of(castingValue.value(byte[].class));
+              }
+            }
+          }
+          callback.onSuccess(status, data);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void hideApp(LauncherResponseCallback callback, Optional<ChipStructs.ApplicationLauncherClusterApplicationStruct> application) {
-      hideApp(chipClusterPtr, callback, application, null);
+      hideApp(callback, application, 0);
     }
 
     public void hideApp(LauncherResponseCallback callback, Optional<ChipStructs.ApplicationLauncherClusterApplicationStruct> application, int timedInvokeTimeoutMs) {
-      hideApp(chipClusterPtr, callback, application, timedInvokeTimeoutMs);
-    }
-
-    private native void launchApp(long chipClusterPtr, LauncherResponseCallback callback, Optional<ChipStructs.ApplicationLauncherClusterApplicationStruct> application, Optional<byte[]> data, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void stopApp(long chipClusterPtr, LauncherResponseCallback callback, Optional<ChipStructs.ApplicationLauncherClusterApplicationStruct> application, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void hideApp(long chipClusterPtr, LauncherResponseCallback callback, Optional<ChipStructs.ApplicationLauncherClusterApplicationStruct> application, @Nullable Integer timedInvokeTimeoutMs);
-
-    public interface LauncherResponseCallback {
+      final long commandId = 2L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long applicationFieldID = 0L;
+      BaseTLVType applicationtlvValue = application.<BaseTLVType>map((nonOptionalapplication) -> nonOptionalapplication.encodeTlv()).orElse(new EmptyType());
+      elements.add(new StructElement(applicationFieldID, applicationtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long statusFieldID = 0L;
+          Integer status = null;
+          final long dataFieldID = 1L;
+          Optional<byte[]> data = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == statusFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                status = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == dataFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+                ByteArrayType castingValue = element.value(ByteArrayType.class);
+                data = Optional.of(castingValue.value(byte[].class));
+              }
+            }
+          }
+          callback.onSuccess(status, data);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface LauncherResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer status, Optional<byte[]> data);
-      void onError(Exception error);
     }
 
-    public interface CatalogListAttributeCallback {
+    public interface CatalogListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Integer> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface CurrentAppAttributeCallback {
+    public interface CurrentAppAttributeCallback extends BaseAttributeCallback {
       void onSuccess(@Nullable ChipStructs.ApplicationLauncherClusterApplicationEPStruct value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readCatalogListAttribute(
         CatalogListAttributeCallback callback) {
-        readCatalogListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CATALOG_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CATALOG_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCatalogListAttribute(
         CatalogListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCatalogListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CATALOG_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CATALOG_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentAppAttribute(
         CurrentAppAttributeCallback callback) {
-        readCurrentAppAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_APP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable ChipStructs.ApplicationLauncherClusterApplicationEPStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_APP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentAppAttribute(
         CurrentAppAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentAppAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_APP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable ChipStructs.ApplicationLauncherClusterApplicationEPStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_APP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readCatalogListAttribute(long chipClusterPtr, CatalogListAttributeCallback callback);
-
-    private native void subscribeCatalogListAttribute(long chipClusterPtr, CatalogListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readCurrentAppAttribute(long chipClusterPtr, CurrentAppAttributeCallback callback);
-
-    private native void subscribeCurrentAppAttribute(long chipClusterPtr, CurrentAppAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class ApplicationBasicCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1293L;
 
+    private static final long VENDOR_NAME_ATTRIBUTE_ID = 0L;
+    private static final long VENDOR_I_D_ATTRIBUTE_ID = 1L;
+    private static final long APPLICATION_NAME_ATTRIBUTE_ID = 2L;
+    private static final long PRODUCT_I_D_ATTRIBUTE_ID = 3L;
+    private static final long APPLICATION_ATTRIBUTE_ID = 4L;
+    private static final long STATUS_ATTRIBUTE_ID = 5L;
+    private static final long APPLICATION_VERSION_ATTRIBUTE_ID = 6L;
+    private static final long ALLOWED_VENDOR_LIST_ATTRIBUTE_ID = 7L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public ApplicationBasicCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    public interface ApplicationAttributeCallback {
+    public interface ApplicationAttributeCallback extends BaseAttributeCallback {
       void onSuccess(ChipStructs.ApplicationBasicClusterApplicationStruct value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AllowedVendorListAttributeCallback {
+    public interface AllowedVendorListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Integer> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readVendorNameAttribute(
         CharStringAttributeCallback callback) {
-        readVendorNameAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, VENDOR_NAME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, VENDOR_NAME_ATTRIBUTE_ID, true);
     }
 
     public void subscribeVendorNameAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeVendorNameAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, VENDOR_NAME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, VENDOR_NAME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readVendorIDAttribute(
         IntegerAttributeCallback callback) {
-        readVendorIDAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, VENDOR_I_D_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, VENDOR_I_D_ATTRIBUTE_ID, true);
     }
 
     public void subscribeVendorIDAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeVendorIDAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, VENDOR_I_D_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, VENDOR_I_D_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readApplicationNameAttribute(
         CharStringAttributeCallback callback) {
-        readApplicationNameAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, APPLICATION_NAME_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, APPLICATION_NAME_ATTRIBUTE_ID, true);
     }
 
     public void subscribeApplicationNameAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeApplicationNameAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, APPLICATION_NAME_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, APPLICATION_NAME_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readProductIDAttribute(
         IntegerAttributeCallback callback) {
-        readProductIDAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRODUCT_I_D_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PRODUCT_I_D_ATTRIBUTE_ID, true);
     }
 
     public void subscribeProductIDAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeProductIDAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PRODUCT_I_D_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PRODUCT_I_D_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readApplicationAttribute(
         ApplicationAttributeCallback callback) {
-        readApplicationAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, APPLICATION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            ChipStructs.ApplicationBasicClusterApplicationStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, APPLICATION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeApplicationAttribute(
         ApplicationAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeApplicationAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, APPLICATION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            ChipStructs.ApplicationBasicClusterApplicationStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, APPLICATION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readStatusAttribute(
         IntegerAttributeCallback callback) {
-        readStatusAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STATUS_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, STATUS_ATTRIBUTE_ID, true);
     }
 
     public void subscribeStatusAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STATUS_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, STATUS_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readApplicationVersionAttribute(
         CharStringAttributeCallback callback) {
-        readApplicationVersionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, APPLICATION_VERSION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, APPLICATION_VERSION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeApplicationVersionAttribute(
         CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeApplicationVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, APPLICATION_VERSION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, APPLICATION_VERSION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAllowedVendorListAttribute(
         AllowedVendorListAttributeCallback callback) {
-        readAllowedVendorListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ALLOWED_VENDOR_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ALLOWED_VENDOR_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAllowedVendorListAttribute(
         AllowedVendorListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAllowedVendorListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ALLOWED_VENDOR_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ALLOWED_VENDOR_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         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 readApplicationAttribute(long chipClusterPtr, ApplicationAttributeCallback callback);
-
-    private native void subscribeApplicationAttribute(long chipClusterPtr, ApplicationAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readStatusAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeStatusAttribute(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 readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class AccountLoginCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 1294L;
 
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public AccountLoginCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
 
     public void getSetupPIN(GetSetupPINResponseCallback callback, String tempAccountIdentifier, int timedInvokeTimeoutMs) {
-      getSetupPIN(chipClusterPtr, callback, tempAccountIdentifier, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long tempAccountIdentifierFieldID = 0L;
+      BaseTLVType tempAccountIdentifiertlvValue = new StringType(tempAccountIdentifier);
+      elements.add(new StructElement(tempAccountIdentifierFieldID, tempAccountIdentifiertlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long setupPINFieldID = 0L;
+          String setupPIN = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == setupPINFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                setupPIN = castingValue.value(String.class);
+              }
+            }
+          }
+          callback.onSuccess(setupPIN);
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
 
     public void login(DefaultClusterCallback callback, String tempAccountIdentifier, String setupPIN, int timedInvokeTimeoutMs) {
-      login(chipClusterPtr, callback, tempAccountIdentifier, setupPIN, timedInvokeTimeoutMs);
-    }
+      final long commandId = 2L;
 
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long tempAccountIdentifierFieldID = 0L;
+      BaseTLVType tempAccountIdentifiertlvValue = new StringType(tempAccountIdentifier);
+      elements.add(new StructElement(tempAccountIdentifierFieldID, tempAccountIdentifiertlvValue));
 
-    public void logout(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      logout(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long setupPINFieldID = 1L;
+      BaseTLVType setupPINtlvValue = new StringType(setupPIN);
+      elements.add(new StructElement(setupPINFieldID, setupPINtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
-    private native void getSetupPIN(long chipClusterPtr, GetSetupPINResponseCallback callback, String tempAccountIdentifier, @Nullable Integer timedInvokeTimeoutMs);
 
-    private native void login(long chipClusterPtr, DefaultClusterCallback callback, String tempAccountIdentifier, String setupPIN, @Nullable Integer timedInvokeTimeoutMs);
+    public void logout(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
+      final long commandId = 3L;
 
-    private native void logout(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface GetSetupPINResponseCallback {
+    public interface GetSetupPINResponseCallback extends BaseClusterCallback {
       void onSuccess(String setupPIN);
-      void onError(Exception error);
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class ElectricalMeasurementCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 2820L;
 
+    private static final long MEASUREMENT_TYPE_ATTRIBUTE_ID = 0L;
+    private static final long DC_VOLTAGE_ATTRIBUTE_ID = 256L;
+    private static final long DC_VOLTAGE_MIN_ATTRIBUTE_ID = 257L;
+    private static final long DC_VOLTAGE_MAX_ATTRIBUTE_ID = 258L;
+    private static final long DC_CURRENT_ATTRIBUTE_ID = 259L;
+    private static final long DC_CURRENT_MIN_ATTRIBUTE_ID = 260L;
+    private static final long DC_CURRENT_MAX_ATTRIBUTE_ID = 261L;
+    private static final long DC_POWER_ATTRIBUTE_ID = 262L;
+    private static final long DC_POWER_MIN_ATTRIBUTE_ID = 263L;
+    private static final long DC_POWER_MAX_ATTRIBUTE_ID = 264L;
+    private static final long DC_VOLTAGE_MULTIPLIER_ATTRIBUTE_ID = 512L;
+    private static final long DC_VOLTAGE_DIVISOR_ATTRIBUTE_ID = 513L;
+    private static final long DC_CURRENT_MULTIPLIER_ATTRIBUTE_ID = 514L;
+    private static final long DC_CURRENT_DIVISOR_ATTRIBUTE_ID = 515L;
+    private static final long DC_POWER_MULTIPLIER_ATTRIBUTE_ID = 516L;
+    private static final long DC_POWER_DIVISOR_ATTRIBUTE_ID = 517L;
+    private static final long AC_FREQUENCY_ATTRIBUTE_ID = 768L;
+    private static final long AC_FREQUENCY_MIN_ATTRIBUTE_ID = 769L;
+    private static final long AC_FREQUENCY_MAX_ATTRIBUTE_ID = 770L;
+    private static final long NEUTRAL_CURRENT_ATTRIBUTE_ID = 771L;
+    private static final long TOTAL_ACTIVE_POWER_ATTRIBUTE_ID = 772L;
+    private static final long TOTAL_REACTIVE_POWER_ATTRIBUTE_ID = 773L;
+    private static final long TOTAL_APPARENT_POWER_ATTRIBUTE_ID = 774L;
+    private static final long MEASURED1ST_HARMONIC_CURRENT_ATTRIBUTE_ID = 775L;
+    private static final long MEASURED3RD_HARMONIC_CURRENT_ATTRIBUTE_ID = 776L;
+    private static final long MEASURED5TH_HARMONIC_CURRENT_ATTRIBUTE_ID = 777L;
+    private static final long MEASURED7TH_HARMONIC_CURRENT_ATTRIBUTE_ID = 778L;
+    private static final long MEASURED9TH_HARMONIC_CURRENT_ATTRIBUTE_ID = 779L;
+    private static final long MEASURED11TH_HARMONIC_CURRENT_ATTRIBUTE_ID = 780L;
+    private static final long MEASURED_PHASE1ST_HARMONIC_CURRENT_ATTRIBUTE_ID = 781L;
+    private static final long MEASURED_PHASE3RD_HARMONIC_CURRENT_ATTRIBUTE_ID = 782L;
+    private static final long MEASURED_PHASE5TH_HARMONIC_CURRENT_ATTRIBUTE_ID = 783L;
+    private static final long MEASURED_PHASE7TH_HARMONIC_CURRENT_ATTRIBUTE_ID = 784L;
+    private static final long MEASURED_PHASE9TH_HARMONIC_CURRENT_ATTRIBUTE_ID = 785L;
+    private static final long MEASURED_PHASE11TH_HARMONIC_CURRENT_ATTRIBUTE_ID = 786L;
+    private static final long AC_FREQUENCY_MULTIPLIER_ATTRIBUTE_ID = 1024L;
+    private static final long AC_FREQUENCY_DIVISOR_ATTRIBUTE_ID = 1025L;
+    private static final long POWER_MULTIPLIER_ATTRIBUTE_ID = 1026L;
+    private static final long POWER_DIVISOR_ATTRIBUTE_ID = 1027L;
+    private static final long HARMONIC_CURRENT_MULTIPLIER_ATTRIBUTE_ID = 1028L;
+    private static final long PHASE_HARMONIC_CURRENT_MULTIPLIER_ATTRIBUTE_ID = 1029L;
+    private static final long INSTANTANEOUS_VOLTAGE_ATTRIBUTE_ID = 1280L;
+    private static final long INSTANTANEOUS_LINE_CURRENT_ATTRIBUTE_ID = 1281L;
+    private static final long INSTANTANEOUS_ACTIVE_CURRENT_ATTRIBUTE_ID = 1282L;
+    private static final long INSTANTANEOUS_REACTIVE_CURRENT_ATTRIBUTE_ID = 1283L;
+    private static final long INSTANTANEOUS_POWER_ATTRIBUTE_ID = 1284L;
+    private static final long RMS_VOLTAGE_ATTRIBUTE_ID = 1285L;
+    private static final long RMS_VOLTAGE_MIN_ATTRIBUTE_ID = 1286L;
+    private static final long RMS_VOLTAGE_MAX_ATTRIBUTE_ID = 1287L;
+    private static final long RMS_CURRENT_ATTRIBUTE_ID = 1288L;
+    private static final long RMS_CURRENT_MIN_ATTRIBUTE_ID = 1289L;
+    private static final long RMS_CURRENT_MAX_ATTRIBUTE_ID = 1290L;
+    private static final long ACTIVE_POWER_ATTRIBUTE_ID = 1291L;
+    private static final long ACTIVE_POWER_MIN_ATTRIBUTE_ID = 1292L;
+    private static final long ACTIVE_POWER_MAX_ATTRIBUTE_ID = 1293L;
+    private static final long REACTIVE_POWER_ATTRIBUTE_ID = 1294L;
+    private static final long APPARENT_POWER_ATTRIBUTE_ID = 1295L;
+    private static final long POWER_FACTOR_ATTRIBUTE_ID = 1296L;
+    private static final long AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_ATTRIBUTE_ID = 1297L;
+    private static final long AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_ATTRIBUTE_ID = 1299L;
+    private static final long RMS_EXTREME_OVER_VOLTAGE_PERIOD_ATTRIBUTE_ID = 1300L;
+    private static final long RMS_EXTREME_UNDER_VOLTAGE_PERIOD_ATTRIBUTE_ID = 1301L;
+    private static final long RMS_VOLTAGE_SAG_PERIOD_ATTRIBUTE_ID = 1302L;
+    private static final long RMS_VOLTAGE_SWELL_PERIOD_ATTRIBUTE_ID = 1303L;
+    private static final long AC_VOLTAGE_MULTIPLIER_ATTRIBUTE_ID = 1536L;
+    private static final long AC_VOLTAGE_DIVISOR_ATTRIBUTE_ID = 1537L;
+    private static final long AC_CURRENT_MULTIPLIER_ATTRIBUTE_ID = 1538L;
+    private static final long AC_CURRENT_DIVISOR_ATTRIBUTE_ID = 1539L;
+    private static final long AC_POWER_MULTIPLIER_ATTRIBUTE_ID = 1540L;
+    private static final long AC_POWER_DIVISOR_ATTRIBUTE_ID = 1541L;
+    private static final long OVERLOAD_ALARMS_MASK_ATTRIBUTE_ID = 1792L;
+    private static final long VOLTAGE_OVERLOAD_ATTRIBUTE_ID = 1793L;
+    private static final long CURRENT_OVERLOAD_ATTRIBUTE_ID = 1794L;
+    private static final long AC_OVERLOAD_ALARMS_MASK_ATTRIBUTE_ID = 2048L;
+    private static final long AC_VOLTAGE_OVERLOAD_ATTRIBUTE_ID = 2049L;
+    private static final long AC_CURRENT_OVERLOAD_ATTRIBUTE_ID = 2050L;
+    private static final long AC_ACTIVE_POWER_OVERLOAD_ATTRIBUTE_ID = 2051L;
+    private static final long AC_REACTIVE_POWER_OVERLOAD_ATTRIBUTE_ID = 2052L;
+    private static final long AVERAGE_RMS_OVER_VOLTAGE_ATTRIBUTE_ID = 2053L;
+    private static final long AVERAGE_RMS_UNDER_VOLTAGE_ATTRIBUTE_ID = 2054L;
+    private static final long RMS_EXTREME_OVER_VOLTAGE_ATTRIBUTE_ID = 2055L;
+    private static final long RMS_EXTREME_UNDER_VOLTAGE_ATTRIBUTE_ID = 2056L;
+    private static final long RMS_VOLTAGE_SAG_ATTRIBUTE_ID = 2057L;
+    private static final long RMS_VOLTAGE_SWELL_ATTRIBUTE_ID = 2058L;
+    private static final long LINE_CURRENT_PHASE_B_ATTRIBUTE_ID = 2305L;
+    private static final long ACTIVE_CURRENT_PHASE_B_ATTRIBUTE_ID = 2306L;
+    private static final long REACTIVE_CURRENT_PHASE_B_ATTRIBUTE_ID = 2307L;
+    private static final long RMS_VOLTAGE_PHASE_B_ATTRIBUTE_ID = 2309L;
+    private static final long RMS_VOLTAGE_MIN_PHASE_B_ATTRIBUTE_ID = 2310L;
+    private static final long RMS_VOLTAGE_MAX_PHASE_B_ATTRIBUTE_ID = 2311L;
+    private static final long RMS_CURRENT_PHASE_B_ATTRIBUTE_ID = 2312L;
+    private static final long RMS_CURRENT_MIN_PHASE_B_ATTRIBUTE_ID = 2313L;
+    private static final long RMS_CURRENT_MAX_PHASE_B_ATTRIBUTE_ID = 2314L;
+    private static final long ACTIVE_POWER_PHASE_B_ATTRIBUTE_ID = 2315L;
+    private static final long ACTIVE_POWER_MIN_PHASE_B_ATTRIBUTE_ID = 2316L;
+    private static final long ACTIVE_POWER_MAX_PHASE_B_ATTRIBUTE_ID = 2317L;
+    private static final long REACTIVE_POWER_PHASE_B_ATTRIBUTE_ID = 2318L;
+    private static final long APPARENT_POWER_PHASE_B_ATTRIBUTE_ID = 2319L;
+    private static final long POWER_FACTOR_PHASE_B_ATTRIBUTE_ID = 2320L;
+    private static final long AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHASE_B_ATTRIBUTE_ID = 2321L;
+    private static final long AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHASE_B_ATTRIBUTE_ID = 2322L;
+    private static final long AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHASE_B_ATTRIBUTE_ID = 2323L;
+    private static final long RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHASE_B_ATTRIBUTE_ID = 2324L;
+    private static final long RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHASE_B_ATTRIBUTE_ID = 2325L;
+    private static final long RMS_VOLTAGE_SAG_PERIOD_PHASE_B_ATTRIBUTE_ID = 2326L;
+    private static final long RMS_VOLTAGE_SWELL_PERIOD_PHASE_B_ATTRIBUTE_ID = 2327L;
+    private static final long LINE_CURRENT_PHASE_C_ATTRIBUTE_ID = 2561L;
+    private static final long ACTIVE_CURRENT_PHASE_C_ATTRIBUTE_ID = 2562L;
+    private static final long REACTIVE_CURRENT_PHASE_C_ATTRIBUTE_ID = 2563L;
+    private static final long RMS_VOLTAGE_PHASE_C_ATTRIBUTE_ID = 2565L;
+    private static final long RMS_VOLTAGE_MIN_PHASE_C_ATTRIBUTE_ID = 2566L;
+    private static final long RMS_VOLTAGE_MAX_PHASE_C_ATTRIBUTE_ID = 2567L;
+    private static final long RMS_CURRENT_PHASE_C_ATTRIBUTE_ID = 2568L;
+    private static final long RMS_CURRENT_MIN_PHASE_C_ATTRIBUTE_ID = 2569L;
+    private static final long RMS_CURRENT_MAX_PHASE_C_ATTRIBUTE_ID = 2570L;
+    private static final long ACTIVE_POWER_PHASE_C_ATTRIBUTE_ID = 2571L;
+    private static final long ACTIVE_POWER_MIN_PHASE_C_ATTRIBUTE_ID = 2572L;
+    private static final long ACTIVE_POWER_MAX_PHASE_C_ATTRIBUTE_ID = 2573L;
+    private static final long REACTIVE_POWER_PHASE_C_ATTRIBUTE_ID = 2574L;
+    private static final long APPARENT_POWER_PHASE_C_ATTRIBUTE_ID = 2575L;
+    private static final long POWER_FACTOR_PHASE_C_ATTRIBUTE_ID = 2576L;
+    private static final long AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHASE_C_ATTRIBUTE_ID = 2577L;
+    private static final long AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHASE_C_ATTRIBUTE_ID = 2578L;
+    private static final long AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHASE_C_ATTRIBUTE_ID = 2579L;
+    private static final long RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHASE_C_ATTRIBUTE_ID = 2580L;
+    private static final long RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHASE_C_ATTRIBUTE_ID = 2581L;
+    private static final long RMS_VOLTAGE_SAG_PERIOD_PHASE_C_ATTRIBUTE_ID = 2582L;
+    private static final long RMS_VOLTAGE_SWELL_PERIOD_PHASE_C_ATTRIBUTE_ID = 2583L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public ElectricalMeasurementCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void getProfileInfoCommand(DefaultClusterCallback callback) {
-      getProfileInfoCommand(chipClusterPtr, callback, null);
+      getProfileInfoCommand(callback, 0);
     }
 
     public void getProfileInfoCommand(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      getProfileInfoCommand(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void getMeasurementProfileCommand(DefaultClusterCallback callback, Integer attributeId, Long startTime, Integer numberOfIntervals) {
-      getMeasurementProfileCommand(chipClusterPtr, callback, attributeId, startTime, numberOfIntervals, null);
+      getMeasurementProfileCommand(callback, attributeId, startTime, numberOfIntervals, 0);
     }
 
     public void getMeasurementProfileCommand(DefaultClusterCallback callback, Integer attributeId, Long startTime, Integer numberOfIntervals, int timedInvokeTimeoutMs) {
-      getMeasurementProfileCommand(chipClusterPtr, callback, attributeId, startTime, numberOfIntervals, timedInvokeTimeoutMs);
-    }
+      final long commandId = 1L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long attributeIdFieldID = 0L;
+      BaseTLVType attributeIdtlvValue = new UIntType(attributeId);
+      elements.add(new StructElement(attributeIdFieldID, attributeIdtlvValue));
 
-    private native void getProfileInfoCommand(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
+      final long startTimeFieldID = 1L;
+      BaseTLVType startTimetlvValue = new UIntType(startTime);
+      elements.add(new StructElement(startTimeFieldID, startTimetlvValue));
 
-    private native void getMeasurementProfileCommand(long chipClusterPtr, DefaultClusterCallback callback, Integer attributeId, Long startTime, Integer numberOfIntervals, @Nullable Integer timedInvokeTimeoutMs);
+      final long numberOfIntervalsFieldID = 2L;
+      BaseTLVType numberOfIntervalstlvValue = new UIntType(numberOfIntervals);
+      elements.add(new StructElement(numberOfIntervalsFieldID, numberOfIntervalstlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readMeasurementTypeAttribute(
         LongAttributeCallback callback) {
-        readMeasurementTypeAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_TYPE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASUREMENT_TYPE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasurementTypeAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasurementTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASUREMENT_TYPE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASUREMENT_TYPE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDcVoltageAttribute(
         IntegerAttributeCallback callback) {
-        readDcVoltageAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_VOLTAGE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DC_VOLTAGE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDcVoltageAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDcVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_VOLTAGE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DC_VOLTAGE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDcVoltageMinAttribute(
         IntegerAttributeCallback callback) {
-        readDcVoltageMinAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_VOLTAGE_MIN_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DC_VOLTAGE_MIN_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDcVoltageMinAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDcVoltageMinAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_VOLTAGE_MIN_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DC_VOLTAGE_MIN_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDcVoltageMaxAttribute(
         IntegerAttributeCallback callback) {
-        readDcVoltageMaxAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_VOLTAGE_MAX_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DC_VOLTAGE_MAX_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDcVoltageMaxAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDcVoltageMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_VOLTAGE_MAX_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DC_VOLTAGE_MAX_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDcCurrentAttribute(
         IntegerAttributeCallback callback) {
-        readDcCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DC_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDcCurrentAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDcCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DC_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDcCurrentMinAttribute(
         IntegerAttributeCallback callback) {
-        readDcCurrentMinAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_CURRENT_MIN_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DC_CURRENT_MIN_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDcCurrentMinAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDcCurrentMinAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_CURRENT_MIN_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DC_CURRENT_MIN_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDcCurrentMaxAttribute(
         IntegerAttributeCallback callback) {
-        readDcCurrentMaxAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_CURRENT_MAX_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DC_CURRENT_MAX_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDcCurrentMaxAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDcCurrentMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_CURRENT_MAX_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DC_CURRENT_MAX_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDcPowerAttribute(
         IntegerAttributeCallback callback) {
-        readDcPowerAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_POWER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DC_POWER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDcPowerAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDcPowerAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_POWER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DC_POWER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDcPowerMinAttribute(
         IntegerAttributeCallback callback) {
-        readDcPowerMinAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_POWER_MIN_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DC_POWER_MIN_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDcPowerMinAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDcPowerMinAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_POWER_MIN_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DC_POWER_MIN_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDcPowerMaxAttribute(
         IntegerAttributeCallback callback) {
-        readDcPowerMaxAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_POWER_MAX_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DC_POWER_MAX_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDcPowerMaxAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDcPowerMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_POWER_MAX_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DC_POWER_MAX_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDcVoltageMultiplierAttribute(
         IntegerAttributeCallback callback) {
-        readDcVoltageMultiplierAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_VOLTAGE_MULTIPLIER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DC_VOLTAGE_MULTIPLIER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDcVoltageMultiplierAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDcVoltageMultiplierAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_VOLTAGE_MULTIPLIER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DC_VOLTAGE_MULTIPLIER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDcVoltageDivisorAttribute(
         IntegerAttributeCallback callback) {
-        readDcVoltageDivisorAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_VOLTAGE_DIVISOR_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DC_VOLTAGE_DIVISOR_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDcVoltageDivisorAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDcVoltageDivisorAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_VOLTAGE_DIVISOR_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DC_VOLTAGE_DIVISOR_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDcCurrentMultiplierAttribute(
         IntegerAttributeCallback callback) {
-        readDcCurrentMultiplierAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_CURRENT_MULTIPLIER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DC_CURRENT_MULTIPLIER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDcCurrentMultiplierAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDcCurrentMultiplierAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_CURRENT_MULTIPLIER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DC_CURRENT_MULTIPLIER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDcCurrentDivisorAttribute(
         IntegerAttributeCallback callback) {
-        readDcCurrentDivisorAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_CURRENT_DIVISOR_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DC_CURRENT_DIVISOR_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDcCurrentDivisorAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDcCurrentDivisorAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_CURRENT_DIVISOR_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DC_CURRENT_DIVISOR_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDcPowerMultiplierAttribute(
         IntegerAttributeCallback callback) {
-        readDcPowerMultiplierAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_POWER_MULTIPLIER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DC_POWER_MULTIPLIER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDcPowerMultiplierAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDcPowerMultiplierAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_POWER_MULTIPLIER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DC_POWER_MULTIPLIER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readDcPowerDivisorAttribute(
         IntegerAttributeCallback callback) {
-        readDcPowerDivisorAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_POWER_DIVISOR_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, DC_POWER_DIVISOR_ATTRIBUTE_ID, true);
     }
 
     public void subscribeDcPowerDivisorAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeDcPowerDivisorAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DC_POWER_DIVISOR_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, DC_POWER_DIVISOR_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcFrequencyAttribute(
         IntegerAttributeCallback callback) {
-        readAcFrequencyAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_FREQUENCY_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AC_FREQUENCY_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcFrequencyAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_FREQUENCY_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AC_FREQUENCY_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcFrequencyMinAttribute(
         IntegerAttributeCallback callback) {
-        readAcFrequencyMinAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_FREQUENCY_MIN_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AC_FREQUENCY_MIN_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcFrequencyMinAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcFrequencyMinAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_FREQUENCY_MIN_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AC_FREQUENCY_MIN_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcFrequencyMaxAttribute(
         IntegerAttributeCallback callback) {
-        readAcFrequencyMaxAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_FREQUENCY_MAX_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AC_FREQUENCY_MAX_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcFrequencyMaxAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcFrequencyMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_FREQUENCY_MAX_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AC_FREQUENCY_MAX_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readNeutralCurrentAttribute(
         IntegerAttributeCallback callback) {
-        readNeutralCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NEUTRAL_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NEUTRAL_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeNeutralCurrentAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNeutralCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NEUTRAL_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NEUTRAL_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTotalActivePowerAttribute(
         LongAttributeCallback callback) {
-        readTotalActivePowerAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TOTAL_ACTIVE_POWER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TOTAL_ACTIVE_POWER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTotalActivePowerAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTotalActivePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TOTAL_ACTIVE_POWER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TOTAL_ACTIVE_POWER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTotalReactivePowerAttribute(
         LongAttributeCallback callback) {
-        readTotalReactivePowerAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TOTAL_REACTIVE_POWER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TOTAL_REACTIVE_POWER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTotalReactivePowerAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTotalReactivePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TOTAL_REACTIVE_POWER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TOTAL_REACTIVE_POWER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readTotalApparentPowerAttribute(
         LongAttributeCallback callback) {
-        readTotalApparentPowerAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TOTAL_APPARENT_POWER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TOTAL_APPARENT_POWER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeTotalApparentPowerAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTotalApparentPowerAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TOTAL_APPARENT_POWER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TOTAL_APPARENT_POWER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasured1stHarmonicCurrentAttribute(
         IntegerAttributeCallback callback) {
-        readMeasured1stHarmonicCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED1ST_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED1ST_HARMONIC_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasured1stHarmonicCurrentAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasured1stHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED1ST_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED1ST_HARMONIC_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasured3rdHarmonicCurrentAttribute(
         IntegerAttributeCallback callback) {
-        readMeasured3rdHarmonicCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED3RD_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED3RD_HARMONIC_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasured3rdHarmonicCurrentAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasured3rdHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED3RD_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED3RD_HARMONIC_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasured5thHarmonicCurrentAttribute(
         IntegerAttributeCallback callback) {
-        readMeasured5thHarmonicCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED5TH_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED5TH_HARMONIC_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasured5thHarmonicCurrentAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasured5thHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED5TH_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED5TH_HARMONIC_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasured7thHarmonicCurrentAttribute(
         IntegerAttributeCallback callback) {
-        readMeasured7thHarmonicCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED7TH_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED7TH_HARMONIC_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasured7thHarmonicCurrentAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasured7thHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED7TH_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED7TH_HARMONIC_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasured9thHarmonicCurrentAttribute(
         IntegerAttributeCallback callback) {
-        readMeasured9thHarmonicCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED9TH_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED9TH_HARMONIC_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasured9thHarmonicCurrentAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasured9thHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED9TH_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED9TH_HARMONIC_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasured11thHarmonicCurrentAttribute(
         IntegerAttributeCallback callback) {
-        readMeasured11thHarmonicCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED11TH_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED11TH_HARMONIC_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasured11thHarmonicCurrentAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasured11thHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED11TH_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED11TH_HARMONIC_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasuredPhase1stHarmonicCurrentAttribute(
         IntegerAttributeCallback callback) {
-        readMeasuredPhase1stHarmonicCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_PHASE1ST_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED_PHASE1ST_HARMONIC_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasuredPhase1stHarmonicCurrentAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasuredPhase1stHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_PHASE1ST_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED_PHASE1ST_HARMONIC_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasuredPhase3rdHarmonicCurrentAttribute(
         IntegerAttributeCallback callback) {
-        readMeasuredPhase3rdHarmonicCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_PHASE3RD_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED_PHASE3RD_HARMONIC_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasuredPhase3rdHarmonicCurrentAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasuredPhase3rdHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_PHASE3RD_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED_PHASE3RD_HARMONIC_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasuredPhase5thHarmonicCurrentAttribute(
         IntegerAttributeCallback callback) {
-        readMeasuredPhase5thHarmonicCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_PHASE5TH_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED_PHASE5TH_HARMONIC_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasuredPhase5thHarmonicCurrentAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasuredPhase5thHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_PHASE5TH_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED_PHASE5TH_HARMONIC_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasuredPhase7thHarmonicCurrentAttribute(
         IntegerAttributeCallback callback) {
-        readMeasuredPhase7thHarmonicCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_PHASE7TH_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED_PHASE7TH_HARMONIC_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasuredPhase7thHarmonicCurrentAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasuredPhase7thHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_PHASE7TH_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED_PHASE7TH_HARMONIC_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasuredPhase9thHarmonicCurrentAttribute(
         IntegerAttributeCallback callback) {
-        readMeasuredPhase9thHarmonicCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_PHASE9TH_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED_PHASE9TH_HARMONIC_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasuredPhase9thHarmonicCurrentAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasuredPhase9thHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_PHASE9TH_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED_PHASE9TH_HARMONIC_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readMeasuredPhase11thHarmonicCurrentAttribute(
         IntegerAttributeCallback callback) {
-        readMeasuredPhase11thHarmonicCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_PHASE11TH_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, MEASURED_PHASE11TH_HARMONIC_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeMeasuredPhase11thHarmonicCurrentAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeMeasuredPhase11thHarmonicCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MEASURED_PHASE11TH_HARMONIC_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, MEASURED_PHASE11TH_HARMONIC_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcFrequencyMultiplierAttribute(
         IntegerAttributeCallback callback) {
-        readAcFrequencyMultiplierAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_FREQUENCY_MULTIPLIER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AC_FREQUENCY_MULTIPLIER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcFrequencyMultiplierAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcFrequencyMultiplierAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_FREQUENCY_MULTIPLIER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AC_FREQUENCY_MULTIPLIER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcFrequencyDivisorAttribute(
         IntegerAttributeCallback callback) {
-        readAcFrequencyDivisorAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_FREQUENCY_DIVISOR_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AC_FREQUENCY_DIVISOR_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcFrequencyDivisorAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcFrequencyDivisorAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_FREQUENCY_DIVISOR_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AC_FREQUENCY_DIVISOR_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPowerMultiplierAttribute(
         LongAttributeCallback callback) {
-        readPowerMultiplierAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, POWER_MULTIPLIER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, POWER_MULTIPLIER_ATTRIBUTE_ID, true);
     }
 
     public void subscribePowerMultiplierAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePowerMultiplierAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, POWER_MULTIPLIER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, POWER_MULTIPLIER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPowerDivisorAttribute(
         LongAttributeCallback callback) {
-        readPowerDivisorAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, POWER_DIVISOR_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, POWER_DIVISOR_ATTRIBUTE_ID, true);
     }
 
     public void subscribePowerDivisorAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePowerDivisorAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, POWER_DIVISOR_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, POWER_DIVISOR_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readHarmonicCurrentMultiplierAttribute(
         IntegerAttributeCallback callback) {
-        readHarmonicCurrentMultiplierAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, HARMONIC_CURRENT_MULTIPLIER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, HARMONIC_CURRENT_MULTIPLIER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeHarmonicCurrentMultiplierAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeHarmonicCurrentMultiplierAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, HARMONIC_CURRENT_MULTIPLIER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, HARMONIC_CURRENT_MULTIPLIER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPhaseHarmonicCurrentMultiplierAttribute(
         IntegerAttributeCallback callback) {
-        readPhaseHarmonicCurrentMultiplierAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PHASE_HARMONIC_CURRENT_MULTIPLIER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, PHASE_HARMONIC_CURRENT_MULTIPLIER_ATTRIBUTE_ID, true);
     }
 
     public void subscribePhaseHarmonicCurrentMultiplierAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePhaseHarmonicCurrentMultiplierAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, PHASE_HARMONIC_CURRENT_MULTIPLIER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, PHASE_HARMONIC_CURRENT_MULTIPLIER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readInstantaneousVoltageAttribute(
         IntegerAttributeCallback callback) {
-        readInstantaneousVoltageAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INSTANTANEOUS_VOLTAGE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INSTANTANEOUS_VOLTAGE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeInstantaneousVoltageAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInstantaneousVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INSTANTANEOUS_VOLTAGE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INSTANTANEOUS_VOLTAGE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readInstantaneousLineCurrentAttribute(
         IntegerAttributeCallback callback) {
-        readInstantaneousLineCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INSTANTANEOUS_LINE_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INSTANTANEOUS_LINE_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeInstantaneousLineCurrentAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInstantaneousLineCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INSTANTANEOUS_LINE_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INSTANTANEOUS_LINE_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readInstantaneousActiveCurrentAttribute(
         IntegerAttributeCallback callback) {
-        readInstantaneousActiveCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INSTANTANEOUS_ACTIVE_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INSTANTANEOUS_ACTIVE_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeInstantaneousActiveCurrentAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInstantaneousActiveCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INSTANTANEOUS_ACTIVE_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INSTANTANEOUS_ACTIVE_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readInstantaneousReactiveCurrentAttribute(
         IntegerAttributeCallback callback) {
-        readInstantaneousReactiveCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INSTANTANEOUS_REACTIVE_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INSTANTANEOUS_REACTIVE_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeInstantaneousReactiveCurrentAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInstantaneousReactiveCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INSTANTANEOUS_REACTIVE_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INSTANTANEOUS_REACTIVE_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readInstantaneousPowerAttribute(
         IntegerAttributeCallback callback) {
-        readInstantaneousPowerAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INSTANTANEOUS_POWER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INSTANTANEOUS_POWER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeInstantaneousPowerAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInstantaneousPowerAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INSTANTANEOUS_POWER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INSTANTANEOUS_POWER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsVoltageAttribute(
         IntegerAttributeCallback callback) {
-        readRmsVoltageAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_VOLTAGE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsVoltageAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_VOLTAGE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsVoltageMinAttribute(
         IntegerAttributeCallback callback) {
-        readRmsVoltageMinAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_MIN_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_VOLTAGE_MIN_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsVoltageMinAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsVoltageMinAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_MIN_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_VOLTAGE_MIN_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsVoltageMaxAttribute(
         IntegerAttributeCallback callback) {
-        readRmsVoltageMaxAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_MAX_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_VOLTAGE_MAX_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsVoltageMaxAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsVoltageMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_MAX_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_VOLTAGE_MAX_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsCurrentAttribute(
         IntegerAttributeCallback callback) {
-        readRmsCurrentAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_CURRENT_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_CURRENT_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsCurrentAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_CURRENT_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsCurrentMinAttribute(
         IntegerAttributeCallback callback) {
-        readRmsCurrentMinAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_CURRENT_MIN_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_CURRENT_MIN_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsCurrentMinAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsCurrentMinAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_CURRENT_MIN_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_CURRENT_MIN_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsCurrentMaxAttribute(
         IntegerAttributeCallback callback) {
-        readRmsCurrentMaxAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_CURRENT_MAX_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_CURRENT_MAX_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsCurrentMaxAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsCurrentMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_CURRENT_MAX_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_CURRENT_MAX_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActivePowerAttribute(
         IntegerAttributeCallback callback) {
-        readActivePowerAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_POWER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_POWER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActivePowerAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActivePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_POWER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_POWER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActivePowerMinAttribute(
         IntegerAttributeCallback callback) {
-        readActivePowerMinAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_POWER_MIN_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_POWER_MIN_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActivePowerMinAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActivePowerMinAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_POWER_MIN_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_POWER_MIN_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActivePowerMaxAttribute(
         IntegerAttributeCallback callback) {
-        readActivePowerMaxAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_POWER_MAX_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_POWER_MAX_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActivePowerMaxAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActivePowerMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_POWER_MAX_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_POWER_MAX_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readReactivePowerAttribute(
         IntegerAttributeCallback callback) {
-        readReactivePowerAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REACTIVE_POWER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, REACTIVE_POWER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeReactivePowerAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeReactivePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REACTIVE_POWER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, REACTIVE_POWER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readApparentPowerAttribute(
         IntegerAttributeCallback callback) {
-        readApparentPowerAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, APPARENT_POWER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, APPARENT_POWER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeApparentPowerAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeApparentPowerAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, APPARENT_POWER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, APPARENT_POWER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPowerFactorAttribute(
         IntegerAttributeCallback callback) {
-        readPowerFactorAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, POWER_FACTOR_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, POWER_FACTOR_ATTRIBUTE_ID, true);
     }
 
     public void subscribePowerFactorAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePowerFactorAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, POWER_FACTOR_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, POWER_FACTOR_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageRmsVoltageMeasurementPeriodAttribute(
         IntegerAttributeCallback callback) {
-        readAverageRmsVoltageMeasurementPeriodAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_ATTRIBUTE_ID, true);
     }
 
     public void writeAverageRmsVoltageMeasurementPeriodAttribute(DefaultClusterCallback callback, Integer value) {
-        writeAverageRmsVoltageMeasurementPeriodAttribute(chipClusterPtr, callback, value, null);
+      writeAverageRmsVoltageMeasurementPeriodAttribute(callback, value, 0);
     }
 
     public void writeAverageRmsVoltageMeasurementPeriodAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeAverageRmsVoltageMeasurementPeriodAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeAverageRmsVoltageMeasurementPeriodAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageRmsVoltageMeasurementPeriodAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageRmsUnderVoltageCounterAttribute(
         IntegerAttributeCallback callback) {
-        readAverageRmsUnderVoltageCounterAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_ATTRIBUTE_ID, true);
     }
 
     public void writeAverageRmsUnderVoltageCounterAttribute(DefaultClusterCallback callback, Integer value) {
-        writeAverageRmsUnderVoltageCounterAttribute(chipClusterPtr, callback, value, null);
+      writeAverageRmsUnderVoltageCounterAttribute(callback, value, 0);
     }
 
     public void writeAverageRmsUnderVoltageCounterAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeAverageRmsUnderVoltageCounterAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeAverageRmsUnderVoltageCounterAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageRmsUnderVoltageCounterAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsExtremeOverVoltagePeriodAttribute(
         IntegerAttributeCallback callback) {
-        readRmsExtremeOverVoltagePeriodAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_EXTREME_OVER_VOLTAGE_PERIOD_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_EXTREME_OVER_VOLTAGE_PERIOD_ATTRIBUTE_ID, true);
     }
 
     public void writeRmsExtremeOverVoltagePeriodAttribute(DefaultClusterCallback callback, Integer value) {
-        writeRmsExtremeOverVoltagePeriodAttribute(chipClusterPtr, callback, value, null);
+      writeRmsExtremeOverVoltagePeriodAttribute(callback, value, 0);
     }
 
     public void writeRmsExtremeOverVoltagePeriodAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeRmsExtremeOverVoltagePeriodAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), RMS_EXTREME_OVER_VOLTAGE_PERIOD_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeRmsExtremeOverVoltagePeriodAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsExtremeOverVoltagePeriodAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_EXTREME_OVER_VOLTAGE_PERIOD_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_EXTREME_OVER_VOLTAGE_PERIOD_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsExtremeUnderVoltagePeriodAttribute(
         IntegerAttributeCallback callback) {
-        readRmsExtremeUnderVoltagePeriodAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_EXTREME_UNDER_VOLTAGE_PERIOD_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_EXTREME_UNDER_VOLTAGE_PERIOD_ATTRIBUTE_ID, true);
     }
 
     public void writeRmsExtremeUnderVoltagePeriodAttribute(DefaultClusterCallback callback, Integer value) {
-        writeRmsExtremeUnderVoltagePeriodAttribute(chipClusterPtr, callback, value, null);
+      writeRmsExtremeUnderVoltagePeriodAttribute(callback, value, 0);
     }
 
     public void writeRmsExtremeUnderVoltagePeriodAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeRmsExtremeUnderVoltagePeriodAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), RMS_EXTREME_UNDER_VOLTAGE_PERIOD_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeRmsExtremeUnderVoltagePeriodAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsExtremeUnderVoltagePeriodAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_EXTREME_UNDER_VOLTAGE_PERIOD_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_EXTREME_UNDER_VOLTAGE_PERIOD_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsVoltageSagPeriodAttribute(
         IntegerAttributeCallback callback) {
-        readRmsVoltageSagPeriodAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_SAG_PERIOD_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_VOLTAGE_SAG_PERIOD_ATTRIBUTE_ID, true);
     }
 
     public void writeRmsVoltageSagPeriodAttribute(DefaultClusterCallback callback, Integer value) {
-        writeRmsVoltageSagPeriodAttribute(chipClusterPtr, callback, value, null);
+      writeRmsVoltageSagPeriodAttribute(callback, value, 0);
     }
 
     public void writeRmsVoltageSagPeriodAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeRmsVoltageSagPeriodAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), RMS_VOLTAGE_SAG_PERIOD_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeRmsVoltageSagPeriodAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsVoltageSagPeriodAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_SAG_PERIOD_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_VOLTAGE_SAG_PERIOD_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsVoltageSwellPeriodAttribute(
         IntegerAttributeCallback callback) {
-        readRmsVoltageSwellPeriodAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_SWELL_PERIOD_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_VOLTAGE_SWELL_PERIOD_ATTRIBUTE_ID, true);
     }
 
     public void writeRmsVoltageSwellPeriodAttribute(DefaultClusterCallback callback, Integer value) {
-        writeRmsVoltageSwellPeriodAttribute(chipClusterPtr, callback, value, null);
+      writeRmsVoltageSwellPeriodAttribute(callback, value, 0);
     }
 
     public void writeRmsVoltageSwellPeriodAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeRmsVoltageSwellPeriodAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), RMS_VOLTAGE_SWELL_PERIOD_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeRmsVoltageSwellPeriodAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsVoltageSwellPeriodAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_SWELL_PERIOD_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_VOLTAGE_SWELL_PERIOD_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcVoltageMultiplierAttribute(
         IntegerAttributeCallback callback) {
-        readAcVoltageMultiplierAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_VOLTAGE_MULTIPLIER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AC_VOLTAGE_MULTIPLIER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcVoltageMultiplierAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcVoltageMultiplierAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_VOLTAGE_MULTIPLIER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AC_VOLTAGE_MULTIPLIER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcVoltageDivisorAttribute(
         IntegerAttributeCallback callback) {
-        readAcVoltageDivisorAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_VOLTAGE_DIVISOR_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AC_VOLTAGE_DIVISOR_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcVoltageDivisorAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcVoltageDivisorAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_VOLTAGE_DIVISOR_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AC_VOLTAGE_DIVISOR_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcCurrentMultiplierAttribute(
         IntegerAttributeCallback callback) {
-        readAcCurrentMultiplierAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_CURRENT_MULTIPLIER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AC_CURRENT_MULTIPLIER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcCurrentMultiplierAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcCurrentMultiplierAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_CURRENT_MULTIPLIER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AC_CURRENT_MULTIPLIER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcCurrentDivisorAttribute(
         IntegerAttributeCallback callback) {
-        readAcCurrentDivisorAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_CURRENT_DIVISOR_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AC_CURRENT_DIVISOR_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcCurrentDivisorAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcCurrentDivisorAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_CURRENT_DIVISOR_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AC_CURRENT_DIVISOR_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcPowerMultiplierAttribute(
         IntegerAttributeCallback callback) {
-        readAcPowerMultiplierAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_POWER_MULTIPLIER_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AC_POWER_MULTIPLIER_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcPowerMultiplierAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcPowerMultiplierAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_POWER_MULTIPLIER_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AC_POWER_MULTIPLIER_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcPowerDivisorAttribute(
         IntegerAttributeCallback callback) {
-        readAcPowerDivisorAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_POWER_DIVISOR_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AC_POWER_DIVISOR_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcPowerDivisorAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcPowerDivisorAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_POWER_DIVISOR_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AC_POWER_DIVISOR_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readOverloadAlarmsMaskAttribute(
         IntegerAttributeCallback callback) {
-        readOverloadAlarmsMaskAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OVERLOAD_ALARMS_MASK_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OVERLOAD_ALARMS_MASK_ATTRIBUTE_ID, true);
     }
 
     public void writeOverloadAlarmsMaskAttribute(DefaultClusterCallback callback, Integer value) {
-        writeOverloadAlarmsMaskAttribute(chipClusterPtr, callback, value, null);
+      writeOverloadAlarmsMaskAttribute(callback, value, 0);
     }
 
     public void writeOverloadAlarmsMaskAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeOverloadAlarmsMaskAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), OVERLOAD_ALARMS_MASK_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeOverloadAlarmsMaskAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOverloadAlarmsMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OVERLOAD_ALARMS_MASK_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OVERLOAD_ALARMS_MASK_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readVoltageOverloadAttribute(
         IntegerAttributeCallback callback) {
-        readVoltageOverloadAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, VOLTAGE_OVERLOAD_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, VOLTAGE_OVERLOAD_ATTRIBUTE_ID, true);
     }
 
     public void subscribeVoltageOverloadAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeVoltageOverloadAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, VOLTAGE_OVERLOAD_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, VOLTAGE_OVERLOAD_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readCurrentOverloadAttribute(
         IntegerAttributeCallback callback) {
-        readCurrentOverloadAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_OVERLOAD_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CURRENT_OVERLOAD_ATTRIBUTE_ID, true);
     }
 
     public void subscribeCurrentOverloadAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCurrentOverloadAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CURRENT_OVERLOAD_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CURRENT_OVERLOAD_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcOverloadAlarmsMaskAttribute(
         IntegerAttributeCallback callback) {
-        readAcOverloadAlarmsMaskAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_OVERLOAD_ALARMS_MASK_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AC_OVERLOAD_ALARMS_MASK_ATTRIBUTE_ID, true);
     }
 
     public void writeAcOverloadAlarmsMaskAttribute(DefaultClusterCallback callback, Integer value) {
-        writeAcOverloadAlarmsMaskAttribute(chipClusterPtr, callback, value, null);
+      writeAcOverloadAlarmsMaskAttribute(callback, value, 0);
     }
 
     public void writeAcOverloadAlarmsMaskAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeAcOverloadAlarmsMaskAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), AC_OVERLOAD_ALARMS_MASK_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeAcOverloadAlarmsMaskAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcOverloadAlarmsMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_OVERLOAD_ALARMS_MASK_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AC_OVERLOAD_ALARMS_MASK_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcVoltageOverloadAttribute(
         IntegerAttributeCallback callback) {
-        readAcVoltageOverloadAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_VOLTAGE_OVERLOAD_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AC_VOLTAGE_OVERLOAD_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcVoltageOverloadAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcVoltageOverloadAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_VOLTAGE_OVERLOAD_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AC_VOLTAGE_OVERLOAD_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcCurrentOverloadAttribute(
         IntegerAttributeCallback callback) {
-        readAcCurrentOverloadAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_CURRENT_OVERLOAD_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AC_CURRENT_OVERLOAD_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcCurrentOverloadAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcCurrentOverloadAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_CURRENT_OVERLOAD_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AC_CURRENT_OVERLOAD_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcActivePowerOverloadAttribute(
         IntegerAttributeCallback callback) {
-        readAcActivePowerOverloadAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_ACTIVE_POWER_OVERLOAD_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AC_ACTIVE_POWER_OVERLOAD_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcActivePowerOverloadAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcActivePowerOverloadAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_ACTIVE_POWER_OVERLOAD_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AC_ACTIVE_POWER_OVERLOAD_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcReactivePowerOverloadAttribute(
         IntegerAttributeCallback callback) {
-        readAcReactivePowerOverloadAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_REACTIVE_POWER_OVERLOAD_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AC_REACTIVE_POWER_OVERLOAD_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcReactivePowerOverloadAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcReactivePowerOverloadAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AC_REACTIVE_POWER_OVERLOAD_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AC_REACTIVE_POWER_OVERLOAD_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageRmsOverVoltageAttribute(
         IntegerAttributeCallback callback) {
-        readAverageRmsOverVoltageAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_RMS_OVER_VOLTAGE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_RMS_OVER_VOLTAGE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageRmsOverVoltageAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageRmsOverVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_RMS_OVER_VOLTAGE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_RMS_OVER_VOLTAGE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageRmsUnderVoltageAttribute(
         IntegerAttributeCallback callback) {
-        readAverageRmsUnderVoltageAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_RMS_UNDER_VOLTAGE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_RMS_UNDER_VOLTAGE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageRmsUnderVoltageAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageRmsUnderVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_RMS_UNDER_VOLTAGE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_RMS_UNDER_VOLTAGE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsExtremeOverVoltageAttribute(
         IntegerAttributeCallback callback) {
-        readRmsExtremeOverVoltageAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_EXTREME_OVER_VOLTAGE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_EXTREME_OVER_VOLTAGE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsExtremeOverVoltageAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsExtremeOverVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_EXTREME_OVER_VOLTAGE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_EXTREME_OVER_VOLTAGE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsExtremeUnderVoltageAttribute(
         IntegerAttributeCallback callback) {
-        readRmsExtremeUnderVoltageAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_EXTREME_UNDER_VOLTAGE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_EXTREME_UNDER_VOLTAGE_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsExtremeUnderVoltageAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsExtremeUnderVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_EXTREME_UNDER_VOLTAGE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_EXTREME_UNDER_VOLTAGE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsVoltageSagAttribute(
         IntegerAttributeCallback callback) {
-        readRmsVoltageSagAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_SAG_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_VOLTAGE_SAG_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsVoltageSagAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsVoltageSagAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_SAG_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_VOLTAGE_SAG_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsVoltageSwellAttribute(
         IntegerAttributeCallback callback) {
-        readRmsVoltageSwellAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_SWELL_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_VOLTAGE_SWELL_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsVoltageSwellAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsVoltageSwellAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_SWELL_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_VOLTAGE_SWELL_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLineCurrentPhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readLineCurrentPhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LINE_CURRENT_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LINE_CURRENT_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLineCurrentPhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLineCurrentPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LINE_CURRENT_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LINE_CURRENT_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActiveCurrentPhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readActiveCurrentPhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_CURRENT_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_CURRENT_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActiveCurrentPhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActiveCurrentPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_CURRENT_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_CURRENT_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readReactiveCurrentPhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readReactiveCurrentPhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REACTIVE_CURRENT_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, REACTIVE_CURRENT_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribeReactiveCurrentPhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeReactiveCurrentPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REACTIVE_CURRENT_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, REACTIVE_CURRENT_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsVoltagePhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readRmsVoltagePhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_VOLTAGE_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsVoltagePhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsVoltagePhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_VOLTAGE_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsVoltageMinPhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readRmsVoltageMinPhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_MIN_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_VOLTAGE_MIN_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsVoltageMinPhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsVoltageMinPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_MIN_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_VOLTAGE_MIN_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsVoltageMaxPhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readRmsVoltageMaxPhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_MAX_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_VOLTAGE_MAX_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsVoltageMaxPhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsVoltageMaxPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_MAX_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_VOLTAGE_MAX_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsCurrentPhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readRmsCurrentPhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_CURRENT_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_CURRENT_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsCurrentPhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsCurrentPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_CURRENT_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_CURRENT_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsCurrentMinPhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readRmsCurrentMinPhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_CURRENT_MIN_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_CURRENT_MIN_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsCurrentMinPhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsCurrentMinPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_CURRENT_MIN_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_CURRENT_MIN_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsCurrentMaxPhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readRmsCurrentMaxPhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_CURRENT_MAX_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_CURRENT_MAX_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsCurrentMaxPhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsCurrentMaxPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_CURRENT_MAX_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_CURRENT_MAX_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActivePowerPhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readActivePowerPhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_POWER_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_POWER_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActivePowerPhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActivePowerPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_POWER_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_POWER_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActivePowerMinPhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readActivePowerMinPhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_POWER_MIN_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_POWER_MIN_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActivePowerMinPhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActivePowerMinPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_POWER_MIN_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_POWER_MIN_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActivePowerMaxPhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readActivePowerMaxPhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_POWER_MAX_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_POWER_MAX_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActivePowerMaxPhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActivePowerMaxPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_POWER_MAX_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_POWER_MAX_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readReactivePowerPhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readReactivePowerPhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REACTIVE_POWER_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, REACTIVE_POWER_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribeReactivePowerPhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeReactivePowerPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REACTIVE_POWER_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, REACTIVE_POWER_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readApparentPowerPhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readApparentPowerPhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, APPARENT_POWER_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, APPARENT_POWER_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribeApparentPowerPhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeApparentPowerPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, APPARENT_POWER_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, APPARENT_POWER_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPowerFactorPhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readPowerFactorPhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, POWER_FACTOR_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, POWER_FACTOR_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribePowerFactorPhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePowerFactorPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, POWER_FACTOR_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, POWER_FACTOR_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageRmsVoltageMeasurementPeriodPhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readAverageRmsVoltageMeasurementPeriodPhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageRmsVoltageMeasurementPeriodPhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageRmsVoltageMeasurementPeriodPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageRmsOverVoltageCounterPhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readAverageRmsOverVoltageCounterPhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageRmsOverVoltageCounterPhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageRmsOverVoltageCounterPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageRmsUnderVoltageCounterPhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readAverageRmsUnderVoltageCounterPhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageRmsUnderVoltageCounterPhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageRmsUnderVoltageCounterPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsExtremeOverVoltagePeriodPhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readRmsExtremeOverVoltagePeriodPhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsExtremeOverVoltagePeriodPhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsExtremeOverVoltagePeriodPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsExtremeUnderVoltagePeriodPhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readRmsExtremeUnderVoltagePeriodPhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsExtremeUnderVoltagePeriodPhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsExtremeUnderVoltagePeriodPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsVoltageSagPeriodPhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readRmsVoltageSagPeriodPhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_SAG_PERIOD_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_VOLTAGE_SAG_PERIOD_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsVoltageSagPeriodPhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsVoltageSagPeriodPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_SAG_PERIOD_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_VOLTAGE_SAG_PERIOD_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsVoltageSwellPeriodPhaseBAttribute(
         IntegerAttributeCallback callback) {
-        readRmsVoltageSwellPeriodPhaseBAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_SWELL_PERIOD_PHASE_B_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_VOLTAGE_SWELL_PERIOD_PHASE_B_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsVoltageSwellPeriodPhaseBAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsVoltageSwellPeriodPhaseBAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_SWELL_PERIOD_PHASE_B_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_VOLTAGE_SWELL_PERIOD_PHASE_B_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readLineCurrentPhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readLineCurrentPhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LINE_CURRENT_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LINE_CURRENT_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribeLineCurrentPhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLineCurrentPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LINE_CURRENT_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LINE_CURRENT_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActiveCurrentPhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readActiveCurrentPhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_CURRENT_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_CURRENT_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActiveCurrentPhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActiveCurrentPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_CURRENT_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_CURRENT_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readReactiveCurrentPhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readReactiveCurrentPhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REACTIVE_CURRENT_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, REACTIVE_CURRENT_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribeReactiveCurrentPhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeReactiveCurrentPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REACTIVE_CURRENT_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, REACTIVE_CURRENT_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsVoltagePhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readRmsVoltagePhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_VOLTAGE_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsVoltagePhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsVoltagePhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_VOLTAGE_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsVoltageMinPhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readRmsVoltageMinPhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_MIN_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_VOLTAGE_MIN_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsVoltageMinPhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsVoltageMinPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_MIN_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_VOLTAGE_MIN_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsVoltageMaxPhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readRmsVoltageMaxPhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_MAX_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_VOLTAGE_MAX_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsVoltageMaxPhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsVoltageMaxPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_MAX_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_VOLTAGE_MAX_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsCurrentPhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readRmsCurrentPhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_CURRENT_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_CURRENT_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsCurrentPhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsCurrentPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_CURRENT_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_CURRENT_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsCurrentMinPhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readRmsCurrentMinPhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_CURRENT_MIN_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_CURRENT_MIN_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsCurrentMinPhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsCurrentMinPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_CURRENT_MIN_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_CURRENT_MIN_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsCurrentMaxPhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readRmsCurrentMaxPhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_CURRENT_MAX_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_CURRENT_MAX_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsCurrentMaxPhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsCurrentMaxPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_CURRENT_MAX_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_CURRENT_MAX_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActivePowerPhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readActivePowerPhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_POWER_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_POWER_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActivePowerPhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActivePowerPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_POWER_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_POWER_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActivePowerMinPhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readActivePowerMinPhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_POWER_MIN_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_POWER_MIN_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActivePowerMinPhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActivePowerMinPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_POWER_MIN_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_POWER_MIN_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readActivePowerMaxPhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readActivePowerMaxPhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_POWER_MAX_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACTIVE_POWER_MAX_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribeActivePowerMaxPhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeActivePowerMaxPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACTIVE_POWER_MAX_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACTIVE_POWER_MAX_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readReactivePowerPhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readReactivePowerPhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REACTIVE_POWER_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, REACTIVE_POWER_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribeReactivePowerPhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeReactivePowerPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, REACTIVE_POWER_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, REACTIVE_POWER_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readApparentPowerPhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readApparentPowerPhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, APPARENT_POWER_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, APPARENT_POWER_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribeApparentPowerPhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeApparentPowerPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, APPARENT_POWER_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, APPARENT_POWER_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readPowerFactorPhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readPowerFactorPhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, POWER_FACTOR_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, POWER_FACTOR_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribePowerFactorPhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribePowerFactorPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, POWER_FACTOR_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, POWER_FACTOR_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageRmsVoltageMeasurementPeriodPhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readAverageRmsVoltageMeasurementPeriodPhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageRmsVoltageMeasurementPeriodPhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageRmsVoltageMeasurementPeriodPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageRmsOverVoltageCounterPhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readAverageRmsOverVoltageCounterPhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageRmsOverVoltageCounterPhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageRmsOverVoltageCounterPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAverageRmsUnderVoltageCounterPhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readAverageRmsUnderVoltageCounterPhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAverageRmsUnderVoltageCounterPhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAverageRmsUnderVoltageCounterPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsExtremeOverVoltagePeriodPhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readRmsExtremeOverVoltagePeriodPhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsExtremeOverVoltagePeriodPhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsExtremeOverVoltagePeriodPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsExtremeUnderVoltagePeriodPhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readRmsExtremeUnderVoltagePeriodPhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsExtremeUnderVoltagePeriodPhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsExtremeUnderVoltagePeriodPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsVoltageSagPeriodPhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readRmsVoltageSagPeriodPhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_SAG_PERIOD_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_VOLTAGE_SAG_PERIOD_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsVoltageSagPeriodPhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsVoltageSagPeriodPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_SAG_PERIOD_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_VOLTAGE_SAG_PERIOD_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readRmsVoltageSwellPeriodPhaseCAttribute(
         IntegerAttributeCallback callback) {
-        readRmsVoltageSwellPeriodPhaseCAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_SWELL_PERIOD_PHASE_C_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RMS_VOLTAGE_SWELL_PERIOD_PHASE_C_ATTRIBUTE_ID, true);
     }
 
     public void subscribeRmsVoltageSwellPeriodPhaseCAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRmsVoltageSwellPeriodPhaseCAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RMS_VOLTAGE_SWELL_PERIOD_PHASE_C_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RMS_VOLTAGE_SWELL_PERIOD_PHASE_C_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
     }
+  }
 
-    private native void readMeasurementTypeAttribute(long chipClusterPtr, LongAttributeCallback callback);
+  public static class UnitTestingCluster extends BaseChipCluster {
+    public static final long CLUSTER_ID = 4294048773L;
 
-    private native void subscribeMeasurementTypeAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+    private static final long BOOLEAN_ATTRIBUTE_ID = 0L;
+    private static final long BITMAP8_ATTRIBUTE_ID = 1L;
+    private static final long BITMAP16_ATTRIBUTE_ID = 2L;
+    private static final long BITMAP32_ATTRIBUTE_ID = 3L;
+    private static final long BITMAP64_ATTRIBUTE_ID = 4L;
+    private static final long INT8U_ATTRIBUTE_ID = 5L;
+    private static final long INT16U_ATTRIBUTE_ID = 6L;
+    private static final long INT24U_ATTRIBUTE_ID = 7L;
+    private static final long INT32U_ATTRIBUTE_ID = 8L;
+    private static final long INT40U_ATTRIBUTE_ID = 9L;
+    private static final long INT48U_ATTRIBUTE_ID = 10L;
+    private static final long INT56U_ATTRIBUTE_ID = 11L;
+    private static final long INT64U_ATTRIBUTE_ID = 12L;
+    private static final long INT8S_ATTRIBUTE_ID = 13L;
+    private static final long INT16S_ATTRIBUTE_ID = 14L;
+    private static final long INT24S_ATTRIBUTE_ID = 15L;
+    private static final long INT32S_ATTRIBUTE_ID = 16L;
+    private static final long INT40S_ATTRIBUTE_ID = 17L;
+    private static final long INT48S_ATTRIBUTE_ID = 18L;
+    private static final long INT56S_ATTRIBUTE_ID = 19L;
+    private static final long INT64S_ATTRIBUTE_ID = 20L;
+    private static final long ENUM8_ATTRIBUTE_ID = 21L;
+    private static final long ENUM16_ATTRIBUTE_ID = 22L;
+    private static final long FLOAT_SINGLE_ATTRIBUTE_ID = 23L;
+    private static final long FLOAT_DOUBLE_ATTRIBUTE_ID = 24L;
+    private static final long OCTET_STRING_ATTRIBUTE_ID = 25L;
+    private static final long LIST_INT8U_ATTRIBUTE_ID = 26L;
+    private static final long LIST_OCTET_STRING_ATTRIBUTE_ID = 27L;
+    private static final long LIST_STRUCT_OCTET_STRING_ATTRIBUTE_ID = 28L;
+    private static final long LONG_OCTET_STRING_ATTRIBUTE_ID = 29L;
+    private static final long CHAR_STRING_ATTRIBUTE_ID = 30L;
+    private static final long LONG_CHAR_STRING_ATTRIBUTE_ID = 31L;
+    private static final long EPOCH_US_ATTRIBUTE_ID = 32L;
+    private static final long EPOCH_S_ATTRIBUTE_ID = 33L;
+    private static final long VENDOR_ID_ATTRIBUTE_ID = 34L;
+    private static final long LIST_NULLABLES_AND_OPTIONALS_STRUCT_ATTRIBUTE_ID = 35L;
+    private static final long ENUM_ATTR_ATTRIBUTE_ID = 36L;
+    private static final long STRUCT_ATTR_ATTRIBUTE_ID = 37L;
+    private static final long RANGE_RESTRICTED_INT8U_ATTRIBUTE_ID = 38L;
+    private static final long RANGE_RESTRICTED_INT8S_ATTRIBUTE_ID = 39L;
+    private static final long RANGE_RESTRICTED_INT16U_ATTRIBUTE_ID = 40L;
+    private static final long RANGE_RESTRICTED_INT16S_ATTRIBUTE_ID = 41L;
+    private static final long LIST_LONG_OCTET_STRING_ATTRIBUTE_ID = 42L;
+    private static final long LIST_FABRIC_SCOPED_ATTRIBUTE_ID = 43L;
+    private static final long TIMED_WRITE_BOOLEAN_ATTRIBUTE_ID = 48L;
+    private static final long GENERAL_ERROR_BOOLEAN_ATTRIBUTE_ID = 49L;
+    private static final long CLUSTER_ERROR_BOOLEAN_ATTRIBUTE_ID = 50L;
+    private static final long UNSUPPORTED_ATTRIBUTE_ID = 255L;
+    private static final long NULLABLE_BOOLEAN_ATTRIBUTE_ID = 16384L;
+    private static final long NULLABLE_BITMAP8_ATTRIBUTE_ID = 16385L;
+    private static final long NULLABLE_BITMAP16_ATTRIBUTE_ID = 16386L;
+    private static final long NULLABLE_BITMAP32_ATTRIBUTE_ID = 16387L;
+    private static final long NULLABLE_BITMAP64_ATTRIBUTE_ID = 16388L;
+    private static final long NULLABLE_INT8U_ATTRIBUTE_ID = 16389L;
+    private static final long NULLABLE_INT16U_ATTRIBUTE_ID = 16390L;
+    private static final long NULLABLE_INT24U_ATTRIBUTE_ID = 16391L;
+    private static final long NULLABLE_INT32U_ATTRIBUTE_ID = 16392L;
+    private static final long NULLABLE_INT40U_ATTRIBUTE_ID = 16393L;
+    private static final long NULLABLE_INT48U_ATTRIBUTE_ID = 16394L;
+    private static final long NULLABLE_INT56U_ATTRIBUTE_ID = 16395L;
+    private static final long NULLABLE_INT64U_ATTRIBUTE_ID = 16396L;
+    private static final long NULLABLE_INT8S_ATTRIBUTE_ID = 16397L;
+    private static final long NULLABLE_INT16S_ATTRIBUTE_ID = 16398L;
+    private static final long NULLABLE_INT24S_ATTRIBUTE_ID = 16399L;
+    private static final long NULLABLE_INT32S_ATTRIBUTE_ID = 16400L;
+    private static final long NULLABLE_INT40S_ATTRIBUTE_ID = 16401L;
+    private static final long NULLABLE_INT48S_ATTRIBUTE_ID = 16402L;
+    private static final long NULLABLE_INT56S_ATTRIBUTE_ID = 16403L;
+    private static final long NULLABLE_INT64S_ATTRIBUTE_ID = 16404L;
+    private static final long NULLABLE_ENUM8_ATTRIBUTE_ID = 16405L;
+    private static final long NULLABLE_ENUM16_ATTRIBUTE_ID = 16406L;
+    private static final long NULLABLE_FLOAT_SINGLE_ATTRIBUTE_ID = 16407L;
+    private static final long NULLABLE_FLOAT_DOUBLE_ATTRIBUTE_ID = 16408L;
+    private static final long NULLABLE_OCTET_STRING_ATTRIBUTE_ID = 16409L;
+    private static final long NULLABLE_CHAR_STRING_ATTRIBUTE_ID = 16414L;
+    private static final long NULLABLE_ENUM_ATTR_ATTRIBUTE_ID = 16420L;
+    private static final long NULLABLE_STRUCT_ATTRIBUTE_ID = 16421L;
+    private static final long NULLABLE_RANGE_RESTRICTED_INT8U_ATTRIBUTE_ID = 16422L;
+    private static final long NULLABLE_RANGE_RESTRICTED_INT8S_ATTRIBUTE_ID = 16423L;
+    private static final long NULLABLE_RANGE_RESTRICTED_INT16U_ATTRIBUTE_ID = 16424L;
+    private static final long NULLABLE_RANGE_RESTRICTED_INT16S_ATTRIBUTE_ID = 16425L;
+    private static final long WRITE_ONLY_INT8U_ATTRIBUTE_ID = 16426L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
 
-    private native void readDcVoltageAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public UnitTestingCluster(long devicePtr, int endpointId) {
+      super(devicePtr, endpointId, CLUSTER_ID);
+    }
 
-    private native void subscribeDcVoltageAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    @Override
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
-    private native void readDcVoltageMinAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void test(DefaultClusterCallback callback) {
+      test(callback, 0);
+    }
 
-    private native void subscribeDcVoltageMinAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void test(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
+      final long commandId = 0L;
 
-    private native void readDcVoltageMaxAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void subscribeDcVoltageMaxAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void testNotHandled(DefaultClusterCallback callback) {
+      testNotHandled(callback, 0);
+    }
 
-    private native void readDcCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void testNotHandled(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
+      final long commandId = 1L;
 
-    private native void subscribeDcCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void readDcCurrentMinAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void testSpecific(TestSpecificResponseCallback callback) {
+      testSpecific(callback, 0);
+    }
 
-    private native void subscribeDcCurrentMinAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void testSpecific(TestSpecificResponseCallback callback, int timedInvokeTimeoutMs) {
+      final long commandId = 2L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long returnValueFieldID = 0L;
+          Integer returnValue = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == returnValueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                returnValue = castingValue.value(Integer.class);
+              }
+            }
+          }
+          callback.onSuccess(returnValue);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void readDcCurrentMaxAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void testUnknownCommand(DefaultClusterCallback callback) {
+      testUnknownCommand(callback, 0);
+    }
 
-    private native void subscribeDcCurrentMaxAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void testUnknownCommand(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
+      final long commandId = 3L;
 
-    private native void readDcPowerAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void subscribeDcPowerAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void testAddArguments(TestAddArgumentsResponseCallback callback, Integer arg1, Integer arg2) {
+      testAddArguments(callback, arg1, arg2, 0);
+    }
 
-    private native void readDcPowerMinAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void testAddArguments(TestAddArgumentsResponseCallback callback, Integer arg1, Integer arg2, int timedInvokeTimeoutMs) {
+      final long commandId = 4L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long arg1FieldID = 0L;
+      BaseTLVType arg1tlvValue = new UIntType(arg1);
+      elements.add(new StructElement(arg1FieldID, arg1tlvValue));
+
+      final long arg2FieldID = 1L;
+      BaseTLVType arg2tlvValue = new UIntType(arg2);
+      elements.add(new StructElement(arg2FieldID, arg2tlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long returnValueFieldID = 0L;
+          Integer returnValue = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == returnValueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                returnValue = castingValue.value(Integer.class);
+              }
+            }
+          }
+          callback.onSuccess(returnValue);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void subscribeDcPowerMinAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void testSimpleArgumentRequest(TestSimpleArgumentResponseCallback callback, Boolean arg1) {
+      testSimpleArgumentRequest(callback, arg1, 0);
+    }
 
-    private native void readDcPowerMaxAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void testSimpleArgumentRequest(TestSimpleArgumentResponseCallback callback, Boolean arg1, int timedInvokeTimeoutMs) {
+      final long commandId = 5L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long arg1FieldID = 0L;
+      BaseTLVType arg1tlvValue = new BooleanType(arg1);
+      elements.add(new StructElement(arg1FieldID, arg1tlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long returnValueFieldID = 0L;
+          Boolean returnValue = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == returnValueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                returnValue = castingValue.value(Boolean.class);
+              }
+            }
+          }
+          callback.onSuccess(returnValue);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void subscribeDcPowerMaxAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void testStructArrayArgumentRequest(TestStructArrayArgumentResponseCallback callback, ArrayList<ChipStructs.UnitTestingClusterNestedStructList> arg1, ArrayList<ChipStructs.UnitTestingClusterSimpleStruct> arg2, ArrayList<Integer> arg3, ArrayList<Boolean> arg4, Integer arg5, Boolean arg6) {
+      testStructArrayArgumentRequest(callback, arg1, arg2, arg3, arg4, arg5, arg6, 0);
+    }
 
-    private native void readDcVoltageMultiplierAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void testStructArrayArgumentRequest(TestStructArrayArgumentResponseCallback callback, ArrayList<ChipStructs.UnitTestingClusterNestedStructList> arg1, ArrayList<ChipStructs.UnitTestingClusterSimpleStruct> arg2, ArrayList<Integer> arg3, ArrayList<Boolean> arg4, Integer arg5, Boolean arg6, int timedInvokeTimeoutMs) {
+      final long commandId = 6L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long arg1FieldID = 0L;
+      BaseTLVType arg1tlvValue = ArrayType.generateArrayType(arg1, (elementarg1) -> elementarg1.encodeTlv());
+      elements.add(new StructElement(arg1FieldID, arg1tlvValue));
+
+      final long arg2FieldID = 1L;
+      BaseTLVType arg2tlvValue = ArrayType.generateArrayType(arg2, (elementarg2) -> elementarg2.encodeTlv());
+      elements.add(new StructElement(arg2FieldID, arg2tlvValue));
+
+      final long arg3FieldID = 2L;
+      BaseTLVType arg3tlvValue = ArrayType.generateArrayType(arg3, (elementarg3) -> new UIntType(elementarg3));
+      elements.add(new StructElement(arg3FieldID, arg3tlvValue));
+
+      final long arg4FieldID = 3L;
+      BaseTLVType arg4tlvValue = ArrayType.generateArrayType(arg4, (elementarg4) -> new BooleanType(elementarg4));
+      elements.add(new StructElement(arg4FieldID, arg4tlvValue));
+
+      final long arg5FieldID = 4L;
+      BaseTLVType arg5tlvValue = new UIntType(arg5);
+      elements.add(new StructElement(arg5FieldID, arg5tlvValue));
+
+      final long arg6FieldID = 5L;
+      BaseTLVType arg6tlvValue = new BooleanType(arg6);
+      elements.add(new StructElement(arg6FieldID, arg6tlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long arg1FieldID = 0L;
+          ArrayList<ChipStructs.UnitTestingClusterNestedStructList> arg1 = null;
+          final long arg2FieldID = 1L;
+          ArrayList<ChipStructs.UnitTestingClusterSimpleStruct> arg2 = null;
+          final long arg3FieldID = 2L;
+          ArrayList<Integer> arg3 = null;
+          final long arg4FieldID = 3L;
+          ArrayList<Boolean> arg4 = null;
+          final long arg5FieldID = 4L;
+          Integer arg5 = null;
+          final long arg6FieldID = 5L;
+          Boolean arg6 = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == arg1FieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+                ArrayType castingValue = element.value(ArrayType.class);
+                arg1 = castingValue.map((elementcastingValue) -> ChipStructs.UnitTestingClusterNestedStructList.decodeTlv(elementcastingValue));
+              }
+            } else if (element.contextTagNum() == arg2FieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+                ArrayType castingValue = element.value(ArrayType.class);
+                arg2 = castingValue.map((elementcastingValue) -> ChipStructs.UnitTestingClusterSimpleStruct.decodeTlv(elementcastingValue));
+              }
+            } else if (element.contextTagNum() == arg3FieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+                ArrayType castingValue = element.value(ArrayType.class);
+                arg3 = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+              }
+            } else if (element.contextTagNum() == arg4FieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+                ArrayType castingValue = element.value(ArrayType.class);
+                arg4 = castingValue.map((elementcastingValue) -> elementcastingValue.value(Boolean.class));
+              }
+            } else if (element.contextTagNum() == arg5FieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                arg5 = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == arg6FieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                arg6 = castingValue.value(Boolean.class);
+              }
+            }
+          }
+          callback.onSuccess(arg1, arg2, arg3, arg4, arg5, arg6);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void subscribeDcVoltageMultiplierAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void testStructArgumentRequest(BooleanResponseCallback callback, ChipStructs.UnitTestingClusterSimpleStruct arg1) {
+      testStructArgumentRequest(callback, arg1, 0);
+    }
 
-    private native void readDcVoltageDivisorAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void testStructArgumentRequest(BooleanResponseCallback callback, ChipStructs.UnitTestingClusterSimpleStruct arg1, int timedInvokeTimeoutMs) {
+      final long commandId = 7L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long arg1FieldID = 0L;
+      BaseTLVType arg1tlvValue = arg1.encodeTlv();
+      elements.add(new StructElement(arg1FieldID, arg1tlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long valueFieldID = 0L;
+          Boolean value = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == valueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                value = castingValue.value(Boolean.class);
+              }
+            }
+          }
+          callback.onSuccess(value);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void subscribeDcVoltageDivisorAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void testNestedStructArgumentRequest(BooleanResponseCallback callback, ChipStructs.UnitTestingClusterNestedStruct arg1) {
+      testNestedStructArgumentRequest(callback, arg1, 0);
+    }
 
-    private native void readDcCurrentMultiplierAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void testNestedStructArgumentRequest(BooleanResponseCallback callback, ChipStructs.UnitTestingClusterNestedStruct arg1, int timedInvokeTimeoutMs) {
+      final long commandId = 8L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long arg1FieldID = 0L;
+      BaseTLVType arg1tlvValue = arg1.encodeTlv();
+      elements.add(new StructElement(arg1FieldID, arg1tlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long valueFieldID = 0L;
+          Boolean value = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == valueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                value = castingValue.value(Boolean.class);
+              }
+            }
+          }
+          callback.onSuccess(value);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void subscribeDcCurrentMultiplierAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void testListStructArgumentRequest(BooleanResponseCallback callback, ArrayList<ChipStructs.UnitTestingClusterSimpleStruct> arg1) {
+      testListStructArgumentRequest(callback, arg1, 0);
+    }
 
-    private native void readDcCurrentDivisorAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void testListStructArgumentRequest(BooleanResponseCallback callback, ArrayList<ChipStructs.UnitTestingClusterSimpleStruct> arg1, int timedInvokeTimeoutMs) {
+      final long commandId = 9L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long arg1FieldID = 0L;
+      BaseTLVType arg1tlvValue = ArrayType.generateArrayType(arg1, (elementarg1) -> elementarg1.encodeTlv());
+      elements.add(new StructElement(arg1FieldID, arg1tlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long valueFieldID = 0L;
+          Boolean value = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == valueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                value = castingValue.value(Boolean.class);
+              }
+            }
+          }
+          callback.onSuccess(value);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void subscribeDcCurrentDivisorAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void testListInt8UArgumentRequest(BooleanResponseCallback callback, ArrayList<Integer> arg1) {
+      testListInt8UArgumentRequest(callback, arg1, 0);
+    }
 
-    private native void readDcPowerMultiplierAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void testListInt8UArgumentRequest(BooleanResponseCallback callback, ArrayList<Integer> arg1, int timedInvokeTimeoutMs) {
+      final long commandId = 10L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long arg1FieldID = 0L;
+      BaseTLVType arg1tlvValue = ArrayType.generateArrayType(arg1, (elementarg1) -> new UIntType(elementarg1));
+      elements.add(new StructElement(arg1FieldID, arg1tlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long valueFieldID = 0L;
+          Boolean value = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == valueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                value = castingValue.value(Boolean.class);
+              }
+            }
+          }
+          callback.onSuccess(value);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void subscribeDcPowerMultiplierAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void testNestedStructListArgumentRequest(BooleanResponseCallback callback, ChipStructs.UnitTestingClusterNestedStructList arg1) {
+      testNestedStructListArgumentRequest(callback, arg1, 0);
+    }
 
-    private native void readDcPowerDivisorAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void testNestedStructListArgumentRequest(BooleanResponseCallback callback, ChipStructs.UnitTestingClusterNestedStructList arg1, int timedInvokeTimeoutMs) {
+      final long commandId = 11L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long arg1FieldID = 0L;
+      BaseTLVType arg1tlvValue = arg1.encodeTlv();
+      elements.add(new StructElement(arg1FieldID, arg1tlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long valueFieldID = 0L;
+          Boolean value = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == valueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                value = castingValue.value(Boolean.class);
+              }
+            }
+          }
+          callback.onSuccess(value);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void subscribeDcPowerDivisorAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void testListNestedStructListArgumentRequest(BooleanResponseCallback callback, ArrayList<ChipStructs.UnitTestingClusterNestedStructList> arg1) {
+      testListNestedStructListArgumentRequest(callback, arg1, 0);
+    }
 
-    private native void readAcFrequencyAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void testListNestedStructListArgumentRequest(BooleanResponseCallback callback, ArrayList<ChipStructs.UnitTestingClusterNestedStructList> arg1, int timedInvokeTimeoutMs) {
+      final long commandId = 12L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long arg1FieldID = 0L;
+      BaseTLVType arg1tlvValue = ArrayType.generateArrayType(arg1, (elementarg1) -> elementarg1.encodeTlv());
+      elements.add(new StructElement(arg1FieldID, arg1tlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long valueFieldID = 0L;
+          Boolean value = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == valueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                value = castingValue.value(Boolean.class);
+              }
+            }
+          }
+          callback.onSuccess(value);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void subscribeAcFrequencyAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void testListInt8UReverseRequest(TestListInt8UReverseResponseCallback callback, ArrayList<Integer> arg1) {
+      testListInt8UReverseRequest(callback, arg1, 0);
+    }
 
-    private native void readAcFrequencyMinAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void testListInt8UReverseRequest(TestListInt8UReverseResponseCallback callback, ArrayList<Integer> arg1, int timedInvokeTimeoutMs) {
+      final long commandId = 13L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long arg1FieldID = 0L;
+      BaseTLVType arg1tlvValue = ArrayType.generateArrayType(arg1, (elementarg1) -> new UIntType(elementarg1));
+      elements.add(new StructElement(arg1FieldID, arg1tlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long arg1FieldID = 0L;
+          ArrayList<Integer> arg1 = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == arg1FieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+                ArrayType castingValue = element.value(ArrayType.class);
+                arg1 = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+              }
+            }
+          }
+          callback.onSuccess(arg1);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void subscribeAcFrequencyMinAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void testEnumsRequest(TestEnumsResponseCallback callback, Integer arg1, Integer arg2) {
+      testEnumsRequest(callback, arg1, arg2, 0);
+    }
 
-    private native void readAcFrequencyMaxAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void testEnumsRequest(TestEnumsResponseCallback callback, Integer arg1, Integer arg2, int timedInvokeTimeoutMs) {
+      final long commandId = 14L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long arg1FieldID = 0L;
+      BaseTLVType arg1tlvValue = new UIntType(arg1);
+      elements.add(new StructElement(arg1FieldID, arg1tlvValue));
+
+      final long arg2FieldID = 1L;
+      BaseTLVType arg2tlvValue = new UIntType(arg2);
+      elements.add(new StructElement(arg2FieldID, arg2tlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long arg1FieldID = 0L;
+          Integer arg1 = null;
+          final long arg2FieldID = 1L;
+          Integer arg2 = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == arg1FieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                arg1 = castingValue.value(Integer.class);
+              }
+            } else if (element.contextTagNum() == arg2FieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                arg2 = castingValue.value(Integer.class);
+              }
+            }
+          }
+          callback.onSuccess(arg1, arg2);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void subscribeAcFrequencyMaxAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void testNullableOptionalRequest(TestNullableOptionalResponseCallback callback, @Nullable Optional<Integer> arg1) {
+      testNullableOptionalRequest(callback, arg1, 0);
+    }
 
-    private native void readNeutralCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void testNullableOptionalRequest(TestNullableOptionalResponseCallback callback, @Nullable Optional<Integer> arg1, int timedInvokeTimeoutMs) {
+      final long commandId = 15L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long arg1FieldID = 0L;
+      BaseTLVType arg1tlvValue = arg1 != null ? arg1.<BaseTLVType>map((nonOptionalarg1) -> new UIntType(nonOptionalarg1)).orElse(new EmptyType()) : new NullType();
+      elements.add(new StructElement(arg1FieldID, arg1tlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long wasPresentFieldID = 0L;
+          Boolean wasPresent = null;
+          final long wasNullFieldID = 1L;
+          Optional<Boolean> wasNull = Optional.empty();
+          final long valueFieldID = 2L;
+          Optional<Integer> value = Optional.empty();
+          final long originalValueFieldID = 3L;
+          @Nullable Optional<Integer> originalValue = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == wasPresentFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                wasPresent = castingValue.value(Boolean.class);
+              }
+            } else if (element.contextTagNum() == wasNullFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                wasNull = Optional.of(castingValue.value(Boolean.class));
+              }
+            } else if (element.contextTagNum() == valueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                value = Optional.of(castingValue.value(Integer.class));
+              }
+            } else if (element.contextTagNum() == originalValueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                originalValue = Optional.of(castingValue.value(Integer.class));
+              }
+            }
+          }
+          callback.onSuccess(wasPresent, wasNull, value, originalValue);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void subscribeNeutralCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void testComplexNullableOptionalRequest(TestComplexNullableOptionalResponseCallback callback, @Nullable Integer nullableInt, Optional<Integer> optionalInt, @Nullable Optional<Integer> nullableOptionalInt, @Nullable String nullableString, Optional<String> optionalString, @Nullable Optional<String> nullableOptionalString, @Nullable ChipStructs.UnitTestingClusterSimpleStruct nullableStruct, Optional<ChipStructs.UnitTestingClusterSimpleStruct> optionalStruct, @Nullable Optional<ChipStructs.UnitTestingClusterSimpleStruct> nullableOptionalStruct, @Nullable ArrayList<Integer> nullableList, Optional<ArrayList<Integer>> optionalList, @Nullable Optional<ArrayList<Integer>> nullableOptionalList) {
+      testComplexNullableOptionalRequest(callback, nullableInt, optionalInt, nullableOptionalInt, nullableString, optionalString, nullableOptionalString, nullableStruct, optionalStruct, nullableOptionalStruct, nullableList, optionalList, nullableOptionalList, 0);
+    }
 
-    private native void readTotalActivePowerAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void testComplexNullableOptionalRequest(TestComplexNullableOptionalResponseCallback callback, @Nullable Integer nullableInt, Optional<Integer> optionalInt, @Nullable Optional<Integer> nullableOptionalInt, @Nullable String nullableString, Optional<String> optionalString, @Nullable Optional<String> nullableOptionalString, @Nullable ChipStructs.UnitTestingClusterSimpleStruct nullableStruct, Optional<ChipStructs.UnitTestingClusterSimpleStruct> optionalStruct, @Nullable Optional<ChipStructs.UnitTestingClusterSimpleStruct> nullableOptionalStruct, @Nullable ArrayList<Integer> nullableList, Optional<ArrayList<Integer>> optionalList, @Nullable Optional<ArrayList<Integer>> nullableOptionalList, int timedInvokeTimeoutMs) {
+      final long commandId = 16L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long nullableIntFieldID = 0L;
+      BaseTLVType nullableInttlvValue = nullableInt != null ? new UIntType(nullableInt) : new NullType();
+      elements.add(new StructElement(nullableIntFieldID, nullableInttlvValue));
+
+      final long optionalIntFieldID = 1L;
+      BaseTLVType optionalInttlvValue = optionalInt.<BaseTLVType>map((nonOptionaloptionalInt) -> new UIntType(nonOptionaloptionalInt)).orElse(new EmptyType());
+      elements.add(new StructElement(optionalIntFieldID, optionalInttlvValue));
+
+      final long nullableOptionalIntFieldID = 2L;
+      BaseTLVType nullableOptionalInttlvValue = nullableOptionalInt != null ? nullableOptionalInt.<BaseTLVType>map((nonOptionalnullableOptionalInt) -> new UIntType(nonOptionalnullableOptionalInt)).orElse(new EmptyType()) : new NullType();
+      elements.add(new StructElement(nullableOptionalIntFieldID, nullableOptionalInttlvValue));
+
+      final long nullableStringFieldID = 3L;
+      BaseTLVType nullableStringtlvValue = nullableString != null ? new StringType(nullableString) : new NullType();
+      elements.add(new StructElement(nullableStringFieldID, nullableStringtlvValue));
+
+      final long optionalStringFieldID = 4L;
+      BaseTLVType optionalStringtlvValue = optionalString.<BaseTLVType>map((nonOptionaloptionalString) -> new StringType(nonOptionaloptionalString)).orElse(new EmptyType());
+      elements.add(new StructElement(optionalStringFieldID, optionalStringtlvValue));
+
+      final long nullableOptionalStringFieldID = 5L;
+      BaseTLVType nullableOptionalStringtlvValue = nullableOptionalString != null ? nullableOptionalString.<BaseTLVType>map((nonOptionalnullableOptionalString) -> new StringType(nonOptionalnullableOptionalString)).orElse(new EmptyType()) : new NullType();
+      elements.add(new StructElement(nullableOptionalStringFieldID, nullableOptionalStringtlvValue));
+
+      final long nullableStructFieldID = 6L;
+      BaseTLVType nullableStructtlvValue = nullableStruct != null ? nullableStruct.encodeTlv() : new NullType();
+      elements.add(new StructElement(nullableStructFieldID, nullableStructtlvValue));
+
+      final long optionalStructFieldID = 7L;
+      BaseTLVType optionalStructtlvValue = optionalStruct.<BaseTLVType>map((nonOptionaloptionalStruct) -> nonOptionaloptionalStruct.encodeTlv()).orElse(new EmptyType());
+      elements.add(new StructElement(optionalStructFieldID, optionalStructtlvValue));
+
+      final long nullableOptionalStructFieldID = 8L;
+      BaseTLVType nullableOptionalStructtlvValue = nullableOptionalStruct != null ? nullableOptionalStruct.<BaseTLVType>map((nonOptionalnullableOptionalStruct) -> nonOptionalnullableOptionalStruct.encodeTlv()).orElse(new EmptyType()) : new NullType();
+      elements.add(new StructElement(nullableOptionalStructFieldID, nullableOptionalStructtlvValue));
+
+      final long nullableListFieldID = 9L;
+      BaseTLVType nullableListtlvValue = nullableList != null ? ArrayType.generateArrayType(nullableList, (elementnullableList) -> new UIntType(elementnullableList)) : new NullType();
+      elements.add(new StructElement(nullableListFieldID, nullableListtlvValue));
+
+      final long optionalListFieldID = 10L;
+      BaseTLVType optionalListtlvValue = optionalList.<BaseTLVType>map((nonOptionaloptionalList) -> ArrayType.generateArrayType(nonOptionaloptionalList, (elementnonOptionaloptionalList) -> new UIntType(elementnonOptionaloptionalList))).orElse(new EmptyType());
+      elements.add(new StructElement(optionalListFieldID, optionalListtlvValue));
+
+      final long nullableOptionalListFieldID = 11L;
+      BaseTLVType nullableOptionalListtlvValue = nullableOptionalList != null ? nullableOptionalList.<BaseTLVType>map((nonOptionalnullableOptionalList) -> ArrayType.generateArrayType(nonOptionalnullableOptionalList, (elementnonOptionalnullableOptionalList) -> new UIntType(elementnonOptionalnullableOptionalList))).orElse(new EmptyType()) : new NullType();
+      elements.add(new StructElement(nullableOptionalListFieldID, nullableOptionalListtlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long nullableIntWasNullFieldID = 0L;
+          Boolean nullableIntWasNull = null;
+          final long nullableIntValueFieldID = 1L;
+          Optional<Integer> nullableIntValue = Optional.empty();
+          final long optionalIntWasPresentFieldID = 2L;
+          Boolean optionalIntWasPresent = null;
+          final long optionalIntValueFieldID = 3L;
+          Optional<Integer> optionalIntValue = Optional.empty();
+          final long nullableOptionalIntWasPresentFieldID = 4L;
+          Boolean nullableOptionalIntWasPresent = null;
+          final long nullableOptionalIntWasNullFieldID = 5L;
+          Optional<Boolean> nullableOptionalIntWasNull = Optional.empty();
+          final long nullableOptionalIntValueFieldID = 6L;
+          Optional<Integer> nullableOptionalIntValue = Optional.empty();
+          final long nullableStringWasNullFieldID = 7L;
+          Boolean nullableStringWasNull = null;
+          final long nullableStringValueFieldID = 8L;
+          Optional<String> nullableStringValue = Optional.empty();
+          final long optionalStringWasPresentFieldID = 9L;
+          Boolean optionalStringWasPresent = null;
+          final long optionalStringValueFieldID = 10L;
+          Optional<String> optionalStringValue = Optional.empty();
+          final long nullableOptionalStringWasPresentFieldID = 11L;
+          Boolean nullableOptionalStringWasPresent = null;
+          final long nullableOptionalStringWasNullFieldID = 12L;
+          Optional<Boolean> nullableOptionalStringWasNull = Optional.empty();
+          final long nullableOptionalStringValueFieldID = 13L;
+          Optional<String> nullableOptionalStringValue = Optional.empty();
+          final long nullableStructWasNullFieldID = 14L;
+          Boolean nullableStructWasNull = null;
+          final long nullableStructValueFieldID = 15L;
+          Optional<ChipStructs.UnitTestingClusterSimpleStruct> nullableStructValue = Optional.empty();
+          final long optionalStructWasPresentFieldID = 16L;
+          Boolean optionalStructWasPresent = null;
+          final long optionalStructValueFieldID = 17L;
+          Optional<ChipStructs.UnitTestingClusterSimpleStruct> optionalStructValue = Optional.empty();
+          final long nullableOptionalStructWasPresentFieldID = 18L;
+          Boolean nullableOptionalStructWasPresent = null;
+          final long nullableOptionalStructWasNullFieldID = 19L;
+          Optional<Boolean> nullableOptionalStructWasNull = Optional.empty();
+          final long nullableOptionalStructValueFieldID = 20L;
+          Optional<ChipStructs.UnitTestingClusterSimpleStruct> nullableOptionalStructValue = Optional.empty();
+          final long nullableListWasNullFieldID = 21L;
+          Boolean nullableListWasNull = null;
+          final long nullableListValueFieldID = 22L;
+          Optional<ArrayList<Integer>> nullableListValue = Optional.empty();
+          final long optionalListWasPresentFieldID = 23L;
+          Boolean optionalListWasPresent = null;
+          final long optionalListValueFieldID = 24L;
+          Optional<ArrayList<Integer>> optionalListValue = Optional.empty();
+          final long nullableOptionalListWasPresentFieldID = 25L;
+          Boolean nullableOptionalListWasPresent = null;
+          final long nullableOptionalListWasNullFieldID = 26L;
+          Optional<Boolean> nullableOptionalListWasNull = Optional.empty();
+          final long nullableOptionalListValueFieldID = 27L;
+          Optional<ArrayList<Integer>> nullableOptionalListValue = Optional.empty();
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == nullableIntWasNullFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                nullableIntWasNull = castingValue.value(Boolean.class);
+              }
+            } else if (element.contextTagNum() == nullableIntValueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                nullableIntValue = Optional.of(castingValue.value(Integer.class));
+              }
+            } else if (element.contextTagNum() == optionalIntWasPresentFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                optionalIntWasPresent = castingValue.value(Boolean.class);
+              }
+            } else if (element.contextTagNum() == optionalIntValueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                optionalIntValue = Optional.of(castingValue.value(Integer.class));
+              }
+            } else if (element.contextTagNum() == nullableOptionalIntWasPresentFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                nullableOptionalIntWasPresent = castingValue.value(Boolean.class);
+              }
+            } else if (element.contextTagNum() == nullableOptionalIntWasNullFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                nullableOptionalIntWasNull = Optional.of(castingValue.value(Boolean.class));
+              }
+            } else if (element.contextTagNum() == nullableOptionalIntValueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                nullableOptionalIntValue = Optional.of(castingValue.value(Integer.class));
+              }
+            } else if (element.contextTagNum() == nullableStringWasNullFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                nullableStringWasNull = castingValue.value(Boolean.class);
+              }
+            } else if (element.contextTagNum() == nullableStringValueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                nullableStringValue = Optional.of(castingValue.value(String.class));
+              }
+            } else if (element.contextTagNum() == optionalStringWasPresentFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                optionalStringWasPresent = castingValue.value(Boolean.class);
+              }
+            } else if (element.contextTagNum() == optionalStringValueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                optionalStringValue = Optional.of(castingValue.value(String.class));
+              }
+            } else if (element.contextTagNum() == nullableOptionalStringWasPresentFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                nullableOptionalStringWasPresent = castingValue.value(Boolean.class);
+              }
+            } else if (element.contextTagNum() == nullableOptionalStringWasNullFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                nullableOptionalStringWasNull = Optional.of(castingValue.value(Boolean.class));
+              }
+            } else if (element.contextTagNum() == nullableOptionalStringValueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.String) {
+                StringType castingValue = element.value(StringType.class);
+                nullableOptionalStringValue = Optional.of(castingValue.value(String.class));
+              }
+            } else if (element.contextTagNum() == nullableStructWasNullFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                nullableStructWasNull = castingValue.value(Boolean.class);
+              }
+            } else if (element.contextTagNum() == nullableStructValueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+                StructType castingValue = element.value(StructType.class);
+                nullableStructValue = Optional.of(ChipStructs.UnitTestingClusterSimpleStruct.decodeTlv(castingValue));
+              }
+            } else if (element.contextTagNum() == optionalStructWasPresentFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                optionalStructWasPresent = castingValue.value(Boolean.class);
+              }
+            } else if (element.contextTagNum() == optionalStructValueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+                StructType castingValue = element.value(StructType.class);
+                optionalStructValue = Optional.of(ChipStructs.UnitTestingClusterSimpleStruct.decodeTlv(castingValue));
+              }
+            } else if (element.contextTagNum() == nullableOptionalStructWasPresentFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                nullableOptionalStructWasPresent = castingValue.value(Boolean.class);
+              }
+            } else if (element.contextTagNum() == nullableOptionalStructWasNullFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                nullableOptionalStructWasNull = Optional.of(castingValue.value(Boolean.class));
+              }
+            } else if (element.contextTagNum() == nullableOptionalStructValueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+                StructType castingValue = element.value(StructType.class);
+                nullableOptionalStructValue = Optional.of(ChipStructs.UnitTestingClusterSimpleStruct.decodeTlv(castingValue));
+              }
+            } else if (element.contextTagNum() == nullableListWasNullFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                nullableListWasNull = castingValue.value(Boolean.class);
+              }
+            } else if (element.contextTagNum() == nullableListValueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+                ArrayType castingValue = element.value(ArrayType.class);
+                nullableListValue = Optional.of(castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class)));
+              }
+            } else if (element.contextTagNum() == optionalListWasPresentFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                optionalListWasPresent = castingValue.value(Boolean.class);
+              }
+            } else if (element.contextTagNum() == optionalListValueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+                ArrayType castingValue = element.value(ArrayType.class);
+                optionalListValue = Optional.of(castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class)));
+              }
+            } else if (element.contextTagNum() == nullableOptionalListWasPresentFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                nullableOptionalListWasPresent = castingValue.value(Boolean.class);
+              }
+            } else if (element.contextTagNum() == nullableOptionalListWasNullFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+                BooleanType castingValue = element.value(BooleanType.class);
+                nullableOptionalListWasNull = Optional.of(castingValue.value(Boolean.class));
+              }
+            } else if (element.contextTagNum() == nullableOptionalListValueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+                ArrayType castingValue = element.value(ArrayType.class);
+                nullableOptionalListValue = Optional.of(castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class)));
+              }
+            }
+          }
+          callback.onSuccess(nullableIntWasNull, nullableIntValue, optionalIntWasPresent, optionalIntValue, nullableOptionalIntWasPresent, nullableOptionalIntWasNull, nullableOptionalIntValue, nullableStringWasNull, nullableStringValue, optionalStringWasPresent, optionalStringValue, nullableOptionalStringWasPresent, nullableOptionalStringWasNull, nullableOptionalStringValue, nullableStructWasNull, nullableStructValue, optionalStructWasPresent, optionalStructValue, nullableOptionalStructWasPresent, nullableOptionalStructWasNull, nullableOptionalStructValue, nullableListWasNull, nullableListValue, optionalListWasPresent, optionalListValue, nullableOptionalListWasPresent, nullableOptionalListWasNull, nullableOptionalListValue);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void subscribeTotalActivePowerAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+    public void simpleStructEchoRequest(SimpleStructResponseCallback callback, ChipStructs.UnitTestingClusterSimpleStruct arg1) {
+      simpleStructEchoRequest(callback, arg1, 0);
+    }
 
-    private native void readTotalReactivePowerAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void simpleStructEchoRequest(SimpleStructResponseCallback callback, ChipStructs.UnitTestingClusterSimpleStruct arg1, int timedInvokeTimeoutMs) {
+      final long commandId = 17L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long arg1FieldID = 0L;
+      BaseTLVType arg1tlvValue = arg1.encodeTlv();
+      elements.add(new StructElement(arg1FieldID, arg1tlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long arg1FieldID = 0L;
+          ChipStructs.UnitTestingClusterSimpleStruct arg1 = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == arg1FieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+                StructType castingValue = element.value(StructType.class);
+                arg1 = ChipStructs.UnitTestingClusterSimpleStruct.decodeTlv(castingValue);
+              }
+            }
+          }
+          callback.onSuccess(arg1);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void subscribeTotalReactivePowerAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
 
-    private native void readTotalApparentPowerAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void timedInvokeRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
+      final long commandId = 18L;
 
-    private native void subscribeTotalApparentPowerAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void readMeasured1stHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void testSimpleOptionalArgumentRequest(DefaultClusterCallback callback, Optional<Boolean> arg1) {
+      testSimpleOptionalArgumentRequest(callback, arg1, 0);
+    }
 
-    private native void subscribeMeasured1stHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void testSimpleOptionalArgumentRequest(DefaultClusterCallback callback, Optional<Boolean> arg1, int timedInvokeTimeoutMs) {
+      final long commandId = 19L;
 
-    private native void readMeasured3rdHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long arg1FieldID = 0L;
+      BaseTLVType arg1tlvValue = arg1.<BaseTLVType>map((nonOptionalarg1) -> new BooleanType(nonOptionalarg1)).orElse(new EmptyType());
+      elements.add(new StructElement(arg1FieldID, arg1tlvValue));
 
-    private native void subscribeMeasured3rdHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void readMeasured5thHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void testEmitTestEventRequest(TestEmitTestEventResponseCallback callback, Integer arg1, Integer arg2, Boolean arg3) {
+      testEmitTestEventRequest(callback, arg1, arg2, arg3, 0);
+    }
 
-    private native void subscribeMeasured5thHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void testEmitTestEventRequest(TestEmitTestEventResponseCallback callback, Integer arg1, Integer arg2, Boolean arg3, int timedInvokeTimeoutMs) {
+      final long commandId = 20L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long arg1FieldID = 0L;
+      BaseTLVType arg1tlvValue = new UIntType(arg1);
+      elements.add(new StructElement(arg1FieldID, arg1tlvValue));
+
+      final long arg2FieldID = 1L;
+      BaseTLVType arg2tlvValue = new UIntType(arg2);
+      elements.add(new StructElement(arg2FieldID, arg2tlvValue));
+
+      final long arg3FieldID = 2L;
+      BaseTLVType arg3tlvValue = new BooleanType(arg3);
+      elements.add(new StructElement(arg3FieldID, arg3tlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long valueFieldID = 0L;
+          Long value = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == valueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                value = castingValue.value(Long.class);
+              }
+            }
+          }
+          callback.onSuccess(value);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    private native void readMeasured7thHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void testEmitTestFabricScopedEventRequest(TestEmitTestFabricScopedEventResponseCallback callback, Integer arg1) {
+      testEmitTestFabricScopedEventRequest(callback, arg1, 0);
+    }
 
-    private native void subscribeMeasured7thHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void testEmitTestFabricScopedEventRequest(TestEmitTestFabricScopedEventResponseCallback callback, Integer arg1, int timedInvokeTimeoutMs) {
+      final long commandId = 21L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long arg1FieldID = 0L;
+      BaseTLVType arg1tlvValue = new UIntType(arg1);
+      elements.add(new StructElement(arg1FieldID, arg1tlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long valueFieldID = 0L;
+          Long value = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == valueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                value = castingValue.value(Long.class);
+              }
+            }
+          }
+          callback.onSuccess(value);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface TestSpecificResponseCallback extends BaseClusterCallback {
+      void onSuccess(Integer returnValue);
+    }
 
-    private native void readMeasured9thHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public interface TestAddArgumentsResponseCallback extends BaseClusterCallback {
+      void onSuccess(Integer returnValue);
+    }
 
-    private native void subscribeMeasured9thHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public interface TestSimpleArgumentResponseCallback extends BaseClusterCallback {
+      void onSuccess(Boolean returnValue);
+    }
 
-    private native void readMeasured11thHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public interface TestStructArrayArgumentResponseCallback extends BaseClusterCallback {
+      void onSuccess(ArrayList<ChipStructs.UnitTestingClusterNestedStructList> arg1, ArrayList<ChipStructs.UnitTestingClusterSimpleStruct> arg2, ArrayList<Integer> arg3, ArrayList<Boolean> arg4, Integer arg5, Boolean arg6);
+    }
 
-    private native void subscribeMeasured11thHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public interface BooleanResponseCallback extends BaseClusterCallback {
+      void onSuccess(Boolean value);
+    }
 
-    private native void readMeasuredPhase1stHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public interface TestListInt8UReverseResponseCallback extends BaseClusterCallback {
+      void onSuccess(ArrayList<Integer> arg1);
+    }
 
-    private native void subscribeMeasuredPhase1stHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public interface TestEnumsResponseCallback extends BaseClusterCallback {
+      void onSuccess(Integer arg1, Integer arg2);
+    }
 
-    private native void readMeasuredPhase3rdHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public interface TestNullableOptionalResponseCallback extends BaseClusterCallback {
+      void onSuccess(Boolean wasPresent, Optional<Boolean> wasNull, Optional<Integer> value, @Nullable Optional<Integer> originalValue);
+    }
 
-    private native void subscribeMeasuredPhase3rdHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public interface TestComplexNullableOptionalResponseCallback extends BaseClusterCallback {
+      void onSuccess(Boolean nullableIntWasNull, Optional<Integer> nullableIntValue, Boolean optionalIntWasPresent, Optional<Integer> optionalIntValue, Boolean nullableOptionalIntWasPresent, Optional<Boolean> nullableOptionalIntWasNull, Optional<Integer> nullableOptionalIntValue, Boolean nullableStringWasNull, Optional<String> nullableStringValue, Boolean optionalStringWasPresent, Optional<String> optionalStringValue, Boolean nullableOptionalStringWasPresent, Optional<Boolean> nullableOptionalStringWasNull, Optional<String> nullableOptionalStringValue, Boolean nullableStructWasNull, Optional<ChipStructs.UnitTestingClusterSimpleStruct> nullableStructValue, Boolean optionalStructWasPresent, Optional<ChipStructs.UnitTestingClusterSimpleStruct> optionalStructValue, Boolean nullableOptionalStructWasPresent, Optional<Boolean> nullableOptionalStructWasNull, Optional<ChipStructs.UnitTestingClusterSimpleStruct> nullableOptionalStructValue, Boolean nullableListWasNull, Optional<ArrayList<Integer>> nullableListValue, Boolean optionalListWasPresent, Optional<ArrayList<Integer>> optionalListValue, Boolean nullableOptionalListWasPresent, Optional<Boolean> nullableOptionalListWasNull, Optional<ArrayList<Integer>> nullableOptionalListValue);
+    }
 
-    private native void readMeasuredPhase5thHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public interface SimpleStructResponseCallback extends BaseClusterCallback {
+      void onSuccess(ChipStructs.UnitTestingClusterSimpleStruct arg1);
+    }
 
-    private native void subscribeMeasuredPhase5thHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public interface TestEmitTestEventResponseCallback extends BaseClusterCallback {
+      void onSuccess(Long value);
+    }
 
-    private native void readMeasuredPhase7thHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public interface TestEmitTestFabricScopedEventResponseCallback extends BaseClusterCallback {
+      void onSuccess(Long value);
+    }
 
-    private native void subscribeMeasuredPhase7thHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public interface ListInt8uAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Integer> value);
+    }
 
-    private native void readMeasuredPhase9thHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public interface ListOctetStringAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<byte[]> value);
+    }
 
-    private native void subscribeMeasuredPhase9thHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public interface ListStructOctetStringAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<ChipStructs.UnitTestingClusterTestListStructOctet> value);
+    }
 
-    private native void readMeasuredPhase11thHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public interface ListNullablesAndOptionalsStructAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<ChipStructs.UnitTestingClusterNullablesAndOptionalsStruct> value);
+    }
 
-    private native void subscribeMeasuredPhase11thHarmonicCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public interface StructAttrAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(ChipStructs.UnitTestingClusterSimpleStruct value);
+    }
 
-    private native void readAcFrequencyMultiplierAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public interface ListLongOctetStringAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<byte[]> value);
+    }
 
-    private native void subscribeAcFrequencyMultiplierAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public interface ListFabricScopedAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<ChipStructs.UnitTestingClusterTestFabricScoped> value);
+    }
 
-    private native void readAcFrequencyDivisorAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public interface NullableBooleanAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Boolean value);
+    }
 
-    private native void subscribeAcFrequencyDivisorAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public interface NullableBitmap8AttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Integer value);
+    }
 
-    private native void readPowerMultiplierAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public interface NullableBitmap16AttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Integer value);
+    }
 
-    private native void subscribePowerMultiplierAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+    public interface NullableBitmap32AttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Long value);
+    }
 
-    private native void readPowerDivisorAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public interface NullableBitmap64AttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Long value);
+    }
 
-    private native void subscribePowerDivisorAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+    public interface NullableInt8uAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Integer value);
+    }
 
-    private native void readHarmonicCurrentMultiplierAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public interface NullableInt16uAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Integer value);
+    }
 
-    private native void subscribeHarmonicCurrentMultiplierAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public interface NullableInt24uAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Long value);
+    }
 
-    private native void readPhaseHarmonicCurrentMultiplierAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public interface NullableInt32uAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Long value);
+    }
 
-    private native void subscribePhaseHarmonicCurrentMultiplierAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public interface NullableInt40uAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Long value);
+    }
 
-    private native void readInstantaneousVoltageAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public interface NullableInt48uAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Long value);
+    }
 
-    private native void subscribeInstantaneousVoltageAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public interface NullableInt56uAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Long value);
+    }
 
-    private native void readInstantaneousLineCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public interface NullableInt64uAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Long value);
+    }
 
-    private native void subscribeInstantaneousLineCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readInstantaneousActiveCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeInstantaneousActiveCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readInstantaneousReactiveCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeInstantaneousReactiveCurrentAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readInstantaneousPowerAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeInstantaneousPowerAttribute(long chipClusterPtr, IntegerAttributeCallback 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 readReactivePowerAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeReactivePowerAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readApparentPowerAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeApparentPowerAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPowerFactorAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribePowerFactorAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageRmsVoltageMeasurementPeriodAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeAverageRmsVoltageMeasurementPeriodAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeAverageRmsVoltageMeasurementPeriodAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageRmsUnderVoltageCounterAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeAverageRmsUnderVoltageCounterAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeAverageRmsUnderVoltageCounterAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsExtremeOverVoltagePeriodAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeRmsExtremeOverVoltagePeriodAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeRmsExtremeOverVoltagePeriodAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsExtremeUnderVoltagePeriodAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeRmsExtremeUnderVoltagePeriodAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeRmsExtremeUnderVoltagePeriodAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsVoltageSagPeriodAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeRmsVoltageSagPeriodAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeRmsVoltageSagPeriodAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsVoltageSwellPeriodAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeRmsVoltageSwellPeriodAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeRmsVoltageSwellPeriodAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcVoltageMultiplierAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeAcVoltageMultiplierAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcVoltageDivisorAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeAcVoltageDivisorAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcCurrentMultiplierAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeAcCurrentMultiplierAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcCurrentDivisorAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeAcCurrentDivisorAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcPowerMultiplierAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeAcPowerMultiplierAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcPowerDivisorAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeAcPowerDivisorAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readOverloadAlarmsMaskAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeOverloadAlarmsMaskAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeOverloadAlarmsMaskAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readVoltageOverloadAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeVoltageOverloadAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readCurrentOverloadAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeCurrentOverloadAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcOverloadAlarmsMaskAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void writeAcOverloadAlarmsMaskAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeAcOverloadAlarmsMaskAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcVoltageOverloadAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeAcVoltageOverloadAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcCurrentOverloadAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeAcCurrentOverloadAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcActivePowerOverloadAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeAcActivePowerOverloadAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcReactivePowerOverloadAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeAcReactivePowerOverloadAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageRmsOverVoltageAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeAverageRmsOverVoltageAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageRmsUnderVoltageAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeAverageRmsUnderVoltageAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsExtremeOverVoltageAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsExtremeOverVoltageAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsExtremeUnderVoltageAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsExtremeUnderVoltageAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsVoltageSagAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsVoltageSagAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsVoltageSwellAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsVoltageSwellAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLineCurrentPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeLineCurrentPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readActiveCurrentPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeActiveCurrentPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readReactiveCurrentPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeReactiveCurrentPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsVoltagePhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsVoltagePhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsVoltageMinPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsVoltageMinPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsVoltageMaxPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsVoltageMaxPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsCurrentPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsCurrentPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsCurrentMinPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsCurrentMinPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsCurrentMaxPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsCurrentMaxPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readActivePowerPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeActivePowerPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readActivePowerMinPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeActivePowerMinPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readActivePowerMaxPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeActivePowerMaxPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readReactivePowerPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeReactivePowerPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readApparentPowerPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeApparentPowerPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPowerFactorPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribePowerFactorPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageRmsVoltageMeasurementPeriodPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeAverageRmsVoltageMeasurementPeriodPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageRmsOverVoltageCounterPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeAverageRmsOverVoltageCounterPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageRmsUnderVoltageCounterPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeAverageRmsUnderVoltageCounterPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsExtremeOverVoltagePeriodPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsExtremeOverVoltagePeriodPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsExtremeUnderVoltagePeriodPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsExtremeUnderVoltagePeriodPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsVoltageSagPeriodPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsVoltageSagPeriodPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsVoltageSwellPeriodPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsVoltageSwellPeriodPhaseBAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readLineCurrentPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeLineCurrentPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readActiveCurrentPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeActiveCurrentPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readReactiveCurrentPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeReactiveCurrentPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsVoltagePhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsVoltagePhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsVoltageMinPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsVoltageMinPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsVoltageMaxPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsVoltageMaxPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsCurrentPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsCurrentPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsCurrentMinPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsCurrentMinPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsCurrentMaxPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsCurrentMaxPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readActivePowerPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeActivePowerPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readActivePowerMinPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeActivePowerMinPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readActivePowerMaxPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeActivePowerMaxPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readReactivePowerPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeReactivePowerPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readApparentPowerPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeApparentPowerPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readPowerFactorPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribePowerFactorPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageRmsVoltageMeasurementPeriodPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeAverageRmsVoltageMeasurementPeriodPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageRmsOverVoltageCounterPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeAverageRmsOverVoltageCounterPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAverageRmsUnderVoltageCounterPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeAverageRmsUnderVoltageCounterPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsExtremeOverVoltagePeriodPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsExtremeOverVoltagePeriodPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsExtremeUnderVoltagePeriodPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsExtremeUnderVoltagePeriodPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsVoltageSagPeriodPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsVoltageSagPeriodPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readRmsVoltageSwellPeriodPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeRmsVoltageSwellPeriodPhaseCAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
-  }
-
-  public static class UnitTestingCluster extends BaseChipCluster {
-    public static final long CLUSTER_ID = 4294048773L;
-
-    public UnitTestingCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
-    }
-
-    @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
-
-    public void test(DefaultClusterCallback callback) {
-      test(chipClusterPtr, callback, null);
-    }
-
-    public void test(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      test(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
-
-    public void testNotHandled(DefaultClusterCallback callback) {
-      testNotHandled(chipClusterPtr, callback, null);
-    }
-
-    public void testNotHandled(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      testNotHandled(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
-
-    public void testSpecific(TestSpecificResponseCallback callback) {
-      testSpecific(chipClusterPtr, callback, null);
-    }
-
-    public void testSpecific(TestSpecificResponseCallback callback, int timedInvokeTimeoutMs) {
-      testSpecific(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
-
-    public void testUnknownCommand(DefaultClusterCallback callback) {
-      testUnknownCommand(chipClusterPtr, callback, null);
-    }
-
-    public void testUnknownCommand(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      testUnknownCommand(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 testSimpleArgumentRequest(TestSimpleArgumentResponseCallback callback, Boolean arg1) {
-      testSimpleArgumentRequest(chipClusterPtr, callback, arg1, null);
-    }
-
-    public void testSimpleArgumentRequest(TestSimpleArgumentResponseCallback callback, Boolean arg1, int timedInvokeTimeoutMs) {
-      testSimpleArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs);
-    }
-
-    public void testStructArrayArgumentRequest(TestStructArrayArgumentResponseCallback callback, ArrayList<ChipStructs.UnitTestingClusterNestedStructList> arg1, ArrayList<ChipStructs.UnitTestingClusterSimpleStruct> arg2, ArrayList<Integer> arg3, ArrayList<Boolean> arg4, Integer arg5, Boolean arg6) {
-      testStructArrayArgumentRequest(chipClusterPtr, callback, arg1, arg2, arg3, arg4, arg5, arg6, null);
-    }
-
-    public void testStructArrayArgumentRequest(TestStructArrayArgumentResponseCallback callback, ArrayList<ChipStructs.UnitTestingClusterNestedStructList> arg1, ArrayList<ChipStructs.UnitTestingClusterSimpleStruct> arg2, ArrayList<Integer> arg3, ArrayList<Boolean> arg4, Integer arg5, Boolean arg6, int timedInvokeTimeoutMs) {
-      testStructArrayArgumentRequest(chipClusterPtr, callback, arg1, arg2, arg3, arg4, arg5, arg6, timedInvokeTimeoutMs);
-    }
-
-    public void testStructArgumentRequest(BooleanResponseCallback callback, ChipStructs.UnitTestingClusterSimpleStruct arg1) {
-      testStructArgumentRequest(chipClusterPtr, callback, arg1, null);
-    }
-
-    public void testStructArgumentRequest(BooleanResponseCallback callback, ChipStructs.UnitTestingClusterSimpleStruct arg1, int timedInvokeTimeoutMs) {
-      testStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs);
-    }
-
-    public void testNestedStructArgumentRequest(BooleanResponseCallback callback, ChipStructs.UnitTestingClusterNestedStruct arg1) {
-      testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, null);
-    }
-
-    public void testNestedStructArgumentRequest(BooleanResponseCallback callback, ChipStructs.UnitTestingClusterNestedStruct arg1, int timedInvokeTimeoutMs) {
-      testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs);
-    }
-
-    public void testListStructArgumentRequest(BooleanResponseCallback callback, ArrayList<ChipStructs.UnitTestingClusterSimpleStruct> arg1) {
-      testListStructArgumentRequest(chipClusterPtr, callback, arg1, null);
-    }
-
-    public void testListStructArgumentRequest(BooleanResponseCallback callback, ArrayList<ChipStructs.UnitTestingClusterSimpleStruct> arg1, int timedInvokeTimeoutMs) {
-      testListStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs);
-    }
-
-    public void testListInt8UArgumentRequest(BooleanResponseCallback callback, ArrayList<Integer> arg1) {
-      testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, null);
-    }
-
-    public void testListInt8UArgumentRequest(BooleanResponseCallback callback, ArrayList<Integer> arg1, int timedInvokeTimeoutMs) {
-      testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs);
-    }
-
-    public void testNestedStructListArgumentRequest(BooleanResponseCallback callback, ChipStructs.UnitTestingClusterNestedStructList arg1) {
-      testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null);
-    }
-
-    public void testNestedStructListArgumentRequest(BooleanResponseCallback callback, ChipStructs.UnitTestingClusterNestedStructList arg1, int timedInvokeTimeoutMs) {
-      testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs);
-    }
-
-    public void testListNestedStructListArgumentRequest(BooleanResponseCallback callback, ArrayList<ChipStructs.UnitTestingClusterNestedStructList> arg1) {
-      testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null);
-    }
-
-    public void testListNestedStructListArgumentRequest(BooleanResponseCallback callback, ArrayList<ChipStructs.UnitTestingClusterNestedStructList> arg1, int timedInvokeTimeoutMs) {
-      testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs);
-    }
-
-    public void testListInt8UReverseRequest(TestListInt8UReverseResponseCallback callback, ArrayList<Integer> arg1) {
-      testListInt8UReverseRequest(chipClusterPtr, callback, arg1, null);
-    }
-
-    public void testListInt8UReverseRequest(TestListInt8UReverseResponseCallback callback, ArrayList<Integer> arg1, int timedInvokeTimeoutMs) {
-      testListInt8UReverseRequest(chipClusterPtr, callback, arg1, 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 testNullableOptionalRequest(TestNullableOptionalResponseCallback callback, @Nullable Optional<Integer> arg1) {
-      testNullableOptionalRequest(chipClusterPtr, callback, arg1, null);
-    }
-
-    public void testNullableOptionalRequest(TestNullableOptionalResponseCallback callback, @Nullable Optional<Integer> arg1, int timedInvokeTimeoutMs) {
-      testNullableOptionalRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs);
-    }
-
-    public void testComplexNullableOptionalRequest(TestComplexNullableOptionalResponseCallback callback, @Nullable Integer nullableInt, Optional<Integer> optionalInt, @Nullable Optional<Integer> nullableOptionalInt, @Nullable String nullableString, Optional<String> optionalString, @Nullable Optional<String> nullableOptionalString, @Nullable ChipStructs.UnitTestingClusterSimpleStruct nullableStruct, Optional<ChipStructs.UnitTestingClusterSimpleStruct> optionalStruct, @Nullable Optional<ChipStructs.UnitTestingClusterSimpleStruct> nullableOptionalStruct, @Nullable ArrayList<Integer> nullableList, Optional<ArrayList<Integer>> optionalList, @Nullable Optional<ArrayList<Integer>> nullableOptionalList) {
-      testComplexNullableOptionalRequest(chipClusterPtr, callback, nullableInt, optionalInt, nullableOptionalInt, nullableString, optionalString, nullableOptionalString, nullableStruct, optionalStruct, nullableOptionalStruct, nullableList, optionalList, nullableOptionalList, null);
-    }
-
-    public void testComplexNullableOptionalRequest(TestComplexNullableOptionalResponseCallback callback, @Nullable Integer nullableInt, Optional<Integer> optionalInt, @Nullable Optional<Integer> nullableOptionalInt, @Nullable String nullableString, Optional<String> optionalString, @Nullable Optional<String> nullableOptionalString, @Nullable ChipStructs.UnitTestingClusterSimpleStruct nullableStruct, Optional<ChipStructs.UnitTestingClusterSimpleStruct> optionalStruct, @Nullable Optional<ChipStructs.UnitTestingClusterSimpleStruct> nullableOptionalStruct, @Nullable ArrayList<Integer> nullableList, Optional<ArrayList<Integer>> optionalList, @Nullable Optional<ArrayList<Integer>> nullableOptionalList, int timedInvokeTimeoutMs) {
-      testComplexNullableOptionalRequest(chipClusterPtr, callback, nullableInt, optionalInt, nullableOptionalInt, nullableString, optionalString, nullableOptionalString, nullableStruct, optionalStruct, nullableOptionalStruct, nullableList, optionalList, nullableOptionalList, timedInvokeTimeoutMs);
-    }
-
-    public void simpleStructEchoRequest(SimpleStructResponseCallback callback, ChipStructs.UnitTestingClusterSimpleStruct arg1) {
-      simpleStructEchoRequest(chipClusterPtr, callback, arg1, null);
-    }
-
-    public void simpleStructEchoRequest(SimpleStructResponseCallback callback, ChipStructs.UnitTestingClusterSimpleStruct arg1, int timedInvokeTimeoutMs) {
-      simpleStructEchoRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs);
-    }
-
-
-    public void timedInvokeRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      timedInvokeRequest(chipClusterPtr, callback, timedInvokeTimeoutMs);
-    }
-
-    public void testSimpleOptionalArgumentRequest(DefaultClusterCallback callback, Optional<Boolean> arg1) {
-      testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, null);
-    }
-
-    public void testSimpleOptionalArgumentRequest(DefaultClusterCallback callback, Optional<Boolean> arg1, int timedInvokeTimeoutMs) {
-      testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, 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 testEmitTestFabricScopedEventRequest(TestEmitTestFabricScopedEventResponseCallback callback, Integer arg1) {
-      testEmitTestFabricScopedEventRequest(chipClusterPtr, callback, arg1, null);
-    }
-
-    public void testEmitTestFabricScopedEventRequest(TestEmitTestFabricScopedEventResponseCallback callback, Integer arg1, int timedInvokeTimeoutMs) {
-      testEmitTestFabricScopedEventRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs);
-    }
-
-    private native void test(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void testNotHandled(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void testSpecific(long chipClusterPtr, TestSpecificResponseCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void testUnknownCommand(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 testSimpleArgumentRequest(long chipClusterPtr, TestSimpleArgumentResponseCallback callback, Boolean arg1, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void testStructArrayArgumentRequest(long chipClusterPtr, TestStructArrayArgumentResponseCallback callback, ArrayList<ChipStructs.UnitTestingClusterNestedStructList> arg1, ArrayList<ChipStructs.UnitTestingClusterSimpleStruct> arg2, ArrayList<Integer> arg3, ArrayList<Boolean> arg4, Integer arg5, Boolean arg6, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void testStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback callback, ChipStructs.UnitTestingClusterSimpleStruct arg1, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void testNestedStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback callback, ChipStructs.UnitTestingClusterNestedStruct arg1, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void testListStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback callback, ArrayList<ChipStructs.UnitTestingClusterSimpleStruct> arg1, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void testListInt8UArgumentRequest(long chipClusterPtr, BooleanResponseCallback callback, ArrayList<Integer> arg1, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void testNestedStructListArgumentRequest(long chipClusterPtr, BooleanResponseCallback callback, ChipStructs.UnitTestingClusterNestedStructList arg1, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void testListNestedStructListArgumentRequest(long chipClusterPtr, BooleanResponseCallback callback, ArrayList<ChipStructs.UnitTestingClusterNestedStructList> arg1, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void testListInt8UReverseRequest(long chipClusterPtr, TestListInt8UReverseResponseCallback callback, ArrayList<Integer> arg1, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void testEnumsRequest(long chipClusterPtr, TestEnumsResponseCallback callback, Integer arg1, Integer arg2, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void testNullableOptionalRequest(long chipClusterPtr, TestNullableOptionalResponseCallback callback, @Nullable Optional<Integer> arg1, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void testComplexNullableOptionalRequest(long chipClusterPtr, TestComplexNullableOptionalResponseCallback callback, @Nullable Integer nullableInt, Optional<Integer> optionalInt, @Nullable Optional<Integer> nullableOptionalInt, @Nullable String nullableString, Optional<String> optionalString, @Nullable Optional<String> nullableOptionalString, @Nullable ChipStructs.UnitTestingClusterSimpleStruct nullableStruct, Optional<ChipStructs.UnitTestingClusterSimpleStruct> optionalStruct, @Nullable Optional<ChipStructs.UnitTestingClusterSimpleStruct> nullableOptionalStruct, @Nullable ArrayList<Integer> nullableList, Optional<ArrayList<Integer>> optionalList, @Nullable Optional<ArrayList<Integer>> nullableOptionalList, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void simpleStructEchoRequest(long chipClusterPtr, SimpleStructResponseCallback callback, ChipStructs.UnitTestingClusterSimpleStruct arg1, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void timedInvokeRequest(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void testSimpleOptionalArgumentRequest(long chipClusterPtr, DefaultClusterCallback callback, Optional<Boolean> arg1, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void testEmitTestEventRequest(long chipClusterPtr, TestEmitTestEventResponseCallback callback, Integer arg1, Integer arg2, Boolean arg3, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void testEmitTestFabricScopedEventRequest(long chipClusterPtr, TestEmitTestFabricScopedEventResponseCallback callback, Integer arg1, @Nullable Integer timedInvokeTimeoutMs);
-
-    public interface TestSpecificResponseCallback {
-      void onSuccess(Integer returnValue);
-      void onError(Exception error);
-    }
-
-    public interface TestAddArgumentsResponseCallback {
-      void onSuccess(Integer returnValue);
-      void onError(Exception error);
-    }
-
-    public interface TestSimpleArgumentResponseCallback {
-      void onSuccess(Boolean returnValue);
-      void onError(Exception error);
-    }
-
-    public interface TestStructArrayArgumentResponseCallback {
-      void onSuccess(ArrayList<ChipStructs.UnitTestingClusterNestedStructList> arg1, ArrayList<ChipStructs.UnitTestingClusterSimpleStruct> arg2, ArrayList<Integer> arg3, ArrayList<Boolean> arg4, Integer arg5, Boolean arg6);
-      void onError(Exception error);
-    }
-
-    public interface BooleanResponseCallback {
-      void onSuccess(Boolean value);
-      void onError(Exception error);
-    }
-
-    public interface TestListInt8UReverseResponseCallback {
-      void onSuccess(ArrayList<Integer> arg1);
-      void onError(Exception error);
-    }
-
-    public interface TestEnumsResponseCallback {
-      void onSuccess(Integer arg1, Integer arg2);
-      void onError(Exception error);
-    }
-
-    public interface TestNullableOptionalResponseCallback {
-      void onSuccess(Boolean wasPresent, Optional<Boolean> wasNull, Optional<Integer> value, @Nullable Optional<Integer> originalValue);
-      void onError(Exception error);
-    }
-
-    public interface TestComplexNullableOptionalResponseCallback {
-      void onSuccess(Boolean nullableIntWasNull, Optional<Integer> nullableIntValue, Boolean optionalIntWasPresent, Optional<Integer> optionalIntValue, Boolean nullableOptionalIntWasPresent, Optional<Boolean> nullableOptionalIntWasNull, Optional<Integer> nullableOptionalIntValue, Boolean nullableStringWasNull, Optional<String> nullableStringValue, Boolean optionalStringWasPresent, Optional<String> optionalStringValue, Boolean nullableOptionalStringWasPresent, Optional<Boolean> nullableOptionalStringWasNull, Optional<String> nullableOptionalStringValue, Boolean nullableStructWasNull, Optional<ChipStructs.UnitTestingClusterSimpleStruct> nullableStructValue, Boolean optionalStructWasPresent, Optional<ChipStructs.UnitTestingClusterSimpleStruct> optionalStructValue, Boolean nullableOptionalStructWasPresent, Optional<Boolean> nullableOptionalStructWasNull, Optional<ChipStructs.UnitTestingClusterSimpleStruct> nullableOptionalStructValue, Boolean nullableListWasNull, Optional<ArrayList<Integer>> nullableListValue, Boolean optionalListWasPresent, Optional<ArrayList<Integer>> optionalListValue, Boolean nullableOptionalListWasPresent, Optional<Boolean> nullableOptionalListWasNull, Optional<ArrayList<Integer>> nullableOptionalListValue);
-      void onError(Exception error);
-    }
-
-    public interface SimpleStructResponseCallback {
-      void onSuccess(ChipStructs.UnitTestingClusterSimpleStruct arg1);
-      void onError(Exception error);
-    }
-
-    public interface TestEmitTestEventResponseCallback {
-      void onSuccess(Long value);
-      void onError(Exception error);
-    }
-
-    public interface TestEmitTestFabricScopedEventResponseCallback {
-      void onSuccess(Long value);
-      void onError(Exception error);
-    }
-
-    public interface ListInt8uAttributeCallback {
-      void onSuccess(List<Integer> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface ListOctetStringAttributeCallback {
-      void onSuccess(List<byte[]> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface ListStructOctetStringAttributeCallback {
-      void onSuccess(List<ChipStructs.UnitTestingClusterTestListStructOctet> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface ListNullablesAndOptionalsStructAttributeCallback {
-      void onSuccess(List<ChipStructs.UnitTestingClusterNullablesAndOptionalsStruct> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface StructAttrAttributeCallback {
-      void onSuccess(ChipStructs.UnitTestingClusterSimpleStruct value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface ListLongOctetStringAttributeCallback {
-      void onSuccess(List<byte[]> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface ListFabricScopedAttributeCallback {
-      void onSuccess(List<ChipStructs.UnitTestingClusterTestFabricScoped> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableBooleanAttributeCallback {
-      void onSuccess(@Nullable Boolean value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableBitmap8AttributeCallback {
-      void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableBitmap16AttributeCallback {
-      void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableBitmap32AttributeCallback {
-      void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableBitmap64AttributeCallback {
-      void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableInt8uAttributeCallback {
-      void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableInt16uAttributeCallback {
-      void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableInt24uAttributeCallback {
-      void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableInt32uAttributeCallback {
-      void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableInt40uAttributeCallback {
-      void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableInt48uAttributeCallback {
-      void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableInt56uAttributeCallback {
-      void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableInt64uAttributeCallback {
-      void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableInt8sAttributeCallback {
-      void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableInt16sAttributeCallback {
-      void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableInt24sAttributeCallback {
-      void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableInt32sAttributeCallback {
-      void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableInt40sAttributeCallback {
-      void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableInt48sAttributeCallback {
-      void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableInt56sAttributeCallback {
-      void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableInt64sAttributeCallback {
-      void onSuccess(@Nullable Long value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableEnum8AttributeCallback {
-      void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableEnum16AttributeCallback {
-      void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableFloatSingleAttributeCallback {
-      void onSuccess(@Nullable Float value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableFloatDoubleAttributeCallback {
-      void onSuccess(@Nullable Double value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableOctetStringAttributeCallback {
-      void onSuccess(@Nullable byte[] value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableCharStringAttributeCallback {
-      void onSuccess(@Nullable String value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableEnumAttrAttributeCallback {
-      void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableStructAttributeCallback {
-      void onSuccess(@Nullable ChipStructs.UnitTestingClusterSimpleStruct value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableRangeRestrictedInt8uAttributeCallback {
-      void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableRangeRestrictedInt8sAttributeCallback {
-      void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableRangeRestrictedInt16uAttributeCallback {
-      void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface NullableRangeRestrictedInt16sAttributeCallback {
-      void onSuccess(@Nullable Integer value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface GeneratedCommandListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface AcceptedCommandListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface EventListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    public interface AttributeListAttributeCallback {
-      void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
-    }
-
-    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) {
-        writeBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
-
-    public void subscribeBooleanAttribute(
-        BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    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) {
-        writeBitmap8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
-
-    public void subscribeBitmap8Attribute(
-        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBitmap8Attribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    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) {
-        writeBitmap16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
-
-    public void subscribeBitmap16Attribute(
-        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBitmap16Attribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    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) {
-        writeBitmap32Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
-
-    public void subscribeBitmap32Attribute(
-        LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBitmap32Attribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    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) {
-        writeBitmap64Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
-
-    public void subscribeBitmap64Attribute(
-        LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeBitmap64Attribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    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) {
-        writeInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
-
-    public void subscribeInt8uAttribute(
-        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    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) {
-        writeInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
-
-    public void subscribeInt16uAttribute(
-        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    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) {
-        writeInt24uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
-
-    public void subscribeInt24uAttribute(
-        LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInt24uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    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) {
-        writeInt32uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
-
-    public void subscribeInt32uAttribute(
-        LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInt32uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    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) {
-        writeInt40uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
-
-    public void subscribeInt40uAttribute(
-        LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInt40uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    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) {
-        writeInt48uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
-
-    public void subscribeInt48uAttribute(
-        LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInt48uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    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) {
-        writeInt56uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
-
-    public void subscribeInt56uAttribute(
-        LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInt56uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    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) {
-        writeInt64uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
-
-    public void subscribeInt64uAttribute(
-        LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInt64uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    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) {
-        writeInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
-
-    public void subscribeInt8sAttribute(
-        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    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) {
-        writeInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
-
-    public void subscribeInt16sAttribute(
-        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    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) {
-        writeInt24sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
-
-    public void subscribeInt24sAttribute(
-        LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInt24sAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    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) {
-        writeInt32sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
-
-    public void subscribeInt32sAttribute(
-        LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInt32sAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    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) {
-        writeInt40sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
-
-    public void subscribeInt40sAttribute(
-        LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInt40sAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    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) {
-        writeInt48sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
-
-    public void subscribeInt48sAttribute(
-        LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInt48sAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    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) {
-        writeInt56sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
-
-    public void subscribeInt56sAttribute(
-        LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInt56sAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    public void readInt64sAttribute(
-        LongAttributeCallback callback) {
-        readInt64sAttribute(chipClusterPtr, callback);
+    public interface NullableInt8sAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Integer value);
     }
 
-    public void writeInt64sAttribute(DefaultClusterCallback callback, Long value) {
-        writeInt64sAttribute(chipClusterPtr, callback, value, null);
+    public interface NullableInt16sAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Integer value);
     }
 
-    public void writeInt64sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeInt64sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public interface NullableInt24sAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Long value);
     }
 
-    public void subscribeInt64sAttribute(
-        LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeInt64sAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public interface NullableInt32sAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Long value);
     }
 
-    public void readEnum8Attribute(
-        IntegerAttributeCallback callback) {
-        readEnum8Attribute(chipClusterPtr, callback);
+    public interface NullableInt40sAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Long value);
     }
 
-    public void writeEnum8Attribute(DefaultClusterCallback callback, Integer value) {
-        writeEnum8Attribute(chipClusterPtr, callback, value, null);
+    public interface NullableInt48sAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Long value);
     }
 
-    public void writeEnum8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeEnum8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public interface NullableInt56sAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Long value);
     }
 
-    public void subscribeEnum8Attribute(
-        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEnum8Attribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public interface NullableInt64sAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Long value);
     }
 
-    public void readEnum16Attribute(
-        IntegerAttributeCallback callback) {
-        readEnum16Attribute(chipClusterPtr, callback);
+    public interface NullableEnum8AttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Integer value);
     }
 
-    public void writeEnum16Attribute(DefaultClusterCallback callback, Integer value) {
-        writeEnum16Attribute(chipClusterPtr, callback, value, null);
+    public interface NullableEnum16AttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Integer value);
     }
 
-    public void writeEnum16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeEnum16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public interface NullableFloatSingleAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Float value);
     }
 
-    public void subscribeEnum16Attribute(
-        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEnum16Attribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public interface NullableFloatDoubleAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Double value);
     }
 
-    public void readFloatSingleAttribute(
-        FloatAttributeCallback callback) {
-        readFloatSingleAttribute(chipClusterPtr, callback);
+    public interface NullableOctetStringAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable byte[] value);
     }
 
-    public void writeFloatSingleAttribute(DefaultClusterCallback callback, Float value) {
-        writeFloatSingleAttribute(chipClusterPtr, callback, value, null);
+    public interface NullableCharStringAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable String value);
     }
 
-    public void writeFloatSingleAttribute(DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) {
-        writeFloatSingleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public interface NullableEnumAttrAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Integer value);
     }
 
-    public void subscribeFloatSingleAttribute(
-        FloatAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFloatSingleAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public interface NullableStructAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable ChipStructs.UnitTestingClusterSimpleStruct value);
     }
 
-    public void readFloatDoubleAttribute(
-        DoubleAttributeCallback callback) {
-        readFloatDoubleAttribute(chipClusterPtr, callback);
+    public interface NullableRangeRestrictedInt8uAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Integer value);
     }
 
-    public void writeFloatDoubleAttribute(DefaultClusterCallback callback, Double value) {
-        writeFloatDoubleAttribute(chipClusterPtr, callback, value, null);
+    public interface NullableRangeRestrictedInt8sAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Integer value);
     }
 
-    public void writeFloatDoubleAttribute(DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) {
-        writeFloatDoubleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public interface NullableRangeRestrictedInt16uAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Integer value);
     }
 
-    public void subscribeFloatDoubleAttribute(
-        DoubleAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFloatDoubleAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public interface NullableRangeRestrictedInt16sAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(@Nullable Integer value);
     }
 
-    public void readOctetStringAttribute(
-        OctetStringAttributeCallback callback) {
-        readOctetStringAttribute(chipClusterPtr, callback);
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
     }
 
-    public void writeOctetStringAttribute(DefaultClusterCallback callback, byte[] value) {
-        writeOctetStringAttribute(chipClusterPtr, callback, value, null);
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
     }
 
-    public void writeOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) {
-        writeOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
     }
 
-    public void subscribeOctetStringAttribute(
-        OctetStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
+      void onSuccess(List<Long> value);
     }
 
-    public void readListInt8uAttribute(
-        ListInt8uAttributeCallback callback) {
-        readListInt8uAttribute(chipClusterPtr, callback);
-    }
+    public void readBooleanAttribute(
+        BooleanAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BOOLEAN_ATTRIBUTE_ID);
 
-    public void writeListInt8uAttribute(DefaultClusterCallback callback, ArrayList<Integer> value) {
-        writeListInt8uAttribute(chipClusterPtr, callback, value, null);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BOOLEAN_ATTRIBUTE_ID, true);
     }
 
-    public void writeListInt8uAttribute(DefaultClusterCallback callback, ArrayList<Integer> value, int timedWriteTimeoutMs) {
-        writeListInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void writeBooleanAttribute(DefaultClusterCallback callback, Boolean value) {
+      writeBooleanAttribute(callback, value, 0);
     }
 
-    public void subscribeListInt8uAttribute(
-        ListInt8uAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeListInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void writeBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new BooleanType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), BOOLEAN_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void readListOctetStringAttribute(
-        ListOctetStringAttributeCallback callback) {
-        readListOctetStringAttribute(chipClusterPtr, callback);
-    }
+    public void subscribeBooleanAttribute(
+        BooleanAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BOOLEAN_ATTRIBUTE_ID);
 
-    public void writeListOctetStringAttribute(DefaultClusterCallback callback, ArrayList<byte[]> value) {
-        writeListOctetStringAttribute(chipClusterPtr, callback, value, null);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BOOLEAN_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void writeListOctetStringAttribute(DefaultClusterCallback callback, ArrayList<byte[]> value, int timedWriteTimeoutMs) {
-        writeListOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
+    public void readBitmap8Attribute(
+        IntegerAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BITMAP8_ATTRIBUTE_ID);
 
-    public void subscribeListOctetStringAttribute(
-        ListOctetStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeListOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BITMAP8_ATTRIBUTE_ID, true);
     }
 
-    public void readListStructOctetStringAttribute(
-        ListStructOctetStringAttributeCallback callback) {
-        readListStructOctetStringAttribute(chipClusterPtr, callback);
+    public void writeBitmap8Attribute(DefaultClusterCallback callback, Integer value) {
+      writeBitmap8Attribute(callback, value, 0);
     }
 
-    public void writeListStructOctetStringAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.UnitTestingClusterTestListStructOctet> value) {
-        writeListStructOctetStringAttribute(chipClusterPtr, callback, value, null);
+    public void writeBitmap8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), BITMAP8_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void writeListStructOctetStringAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.UnitTestingClusterTestListStructOctet> value, int timedWriteTimeoutMs) {
-        writeListStructOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
+    public void subscribeBitmap8Attribute(
+        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BITMAP8_ATTRIBUTE_ID);
 
-    public void subscribeListStructOctetStringAttribute(
-        ListStructOctetStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeListStructOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BITMAP8_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void readLongOctetStringAttribute(
-        OctetStringAttributeCallback callback) {
-        readLongOctetStringAttribute(chipClusterPtr, callback);
-    }
+    public void readBitmap16Attribute(
+        IntegerAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BITMAP16_ATTRIBUTE_ID);
 
-    public void writeLongOctetStringAttribute(DefaultClusterCallback callback, byte[] value) {
-        writeLongOctetStringAttribute(chipClusterPtr, callback, value, null);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BITMAP16_ATTRIBUTE_ID, true);
     }
 
-    public void writeLongOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) {
-        writeLongOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void writeBitmap16Attribute(DefaultClusterCallback callback, Integer value) {
+      writeBitmap16Attribute(callback, value, 0);
     }
 
-    public void subscribeLongOctetStringAttribute(
-        OctetStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLongOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void writeBitmap16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), BITMAP16_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void readCharStringAttribute(
-        CharStringAttributeCallback callback) {
-        readCharStringAttribute(chipClusterPtr, callback);
-    }
+    public void subscribeBitmap16Attribute(
+        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BITMAP16_ATTRIBUTE_ID);
 
-    public void writeCharStringAttribute(DefaultClusterCallback callback, String value) {
-        writeCharStringAttribute(chipClusterPtr, callback, value, null);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BITMAP16_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void writeCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) {
-        writeCharStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
+    public void readBitmap32Attribute(
+        LongAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BITMAP32_ATTRIBUTE_ID);
 
-    public void subscribeCharStringAttribute(
-        CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeCharStringAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BITMAP32_ATTRIBUTE_ID, true);
     }
 
-    public void readLongCharStringAttribute(
-        CharStringAttributeCallback callback) {
-        readLongCharStringAttribute(chipClusterPtr, callback);
+    public void writeBitmap32Attribute(DefaultClusterCallback callback, Long value) {
+      writeBitmap32Attribute(callback, value, 0);
     }
 
-    public void writeLongCharStringAttribute(DefaultClusterCallback callback, String value) {
-        writeLongCharStringAttribute(chipClusterPtr, callback, value, null);
+    public void writeBitmap32Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), BITMAP32_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void writeLongCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) {
-        writeLongCharStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
+    public void subscribeBitmap32Attribute(
+        LongAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BITMAP32_ATTRIBUTE_ID);
 
-    public void subscribeLongCharStringAttribute(
-        CharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeLongCharStringAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BITMAP32_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void readEpochUsAttribute(
+    public void readBitmap64Attribute(
         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) {
-        writeEpochUsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BITMAP64_ATTRIBUTE_ID);
 
-    public void subscribeEpochUsAttribute(
-        LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEpochUsAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    public void readEpochSAttribute(
-        LongAttributeCallback callback) {
-        readEpochSAttribute(chipClusterPtr, callback);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, BITMAP64_ATTRIBUTE_ID, true);
     }
 
-    public void writeEpochSAttribute(DefaultClusterCallback callback, Long value) {
-        writeEpochSAttribute(chipClusterPtr, callback, value, null);
+    public void writeBitmap64Attribute(DefaultClusterCallback callback, Long value) {
+      writeBitmap64Attribute(callback, value, 0);
     }
 
-    public void writeEpochSAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeEpochSAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void writeBitmap64Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), BITMAP64_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void subscribeEpochSAttribute(
+    public void subscribeBitmap64Attribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEpochSAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BITMAP64_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, BITMAP64_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void readVendorIdAttribute(
+    public void readInt8uAttribute(
         IntegerAttributeCallback callback) {
-        readVendorIdAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT8U_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INT8U_ATTRIBUTE_ID, true);
     }
 
-    public void writeVendorIdAttribute(DefaultClusterCallback callback, Integer value) {
-        writeVendorIdAttribute(chipClusterPtr, callback, value, null);
+    public void writeInt8uAttribute(DefaultClusterCallback callback, Integer value) {
+      writeInt8uAttribute(callback, value, 0);
     }
 
-    public void writeVendorIdAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeVendorIdAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void writeInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), INT8U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void subscribeVendorIdAttribute(
+    public void subscribeInt8uAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeVendorIdAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT8U_ATTRIBUTE_ID);
 
-    public void readListNullablesAndOptionalsStructAttribute(
-        ListNullablesAndOptionalsStructAttributeCallback callback) {
-        readListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INT8U_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void writeListNullablesAndOptionalsStructAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.UnitTestingClusterNullablesAndOptionalsStruct> value) {
-        writeListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback, value, null);
-    }
+    public void readInt16uAttribute(
+        IntegerAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT16U_ATTRIBUTE_ID);
 
-    public void writeListNullablesAndOptionalsStructAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.UnitTestingClusterNullablesAndOptionalsStruct> value, int timedWriteTimeoutMs) {
-        writeListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INT16U_ATTRIBUTE_ID, true);
     }
 
-    public void subscribeListNullablesAndOptionalsStructAttribute(
-        ListNullablesAndOptionalsStructAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void writeInt16uAttribute(DefaultClusterCallback callback, Integer value) {
+      writeInt16uAttribute(callback, value, 0);
     }
 
-    public void readEnumAttrAttribute(
-        IntegerAttributeCallback callback) {
-        readEnumAttrAttribute(chipClusterPtr, callback);
+    public void writeInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), INT16U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void writeEnumAttrAttribute(DefaultClusterCallback callback, Integer value) {
-        writeEnumAttrAttribute(chipClusterPtr, callback, value, null);
-    }
+    public void subscribeInt16uAttribute(
+        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT16U_ATTRIBUTE_ID);
 
-    public void writeEnumAttrAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeEnumAttrAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INT16U_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void subscribeEnumAttrAttribute(
-        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEnumAttrAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+    public void readInt24uAttribute(
+        LongAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT24U_ATTRIBUTE_ID);
 
-    public void readStructAttrAttribute(
-        StructAttrAttributeCallback callback) {
-        readStructAttrAttribute(chipClusterPtr, callback);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INT24U_ATTRIBUTE_ID, true);
     }
 
-    public void writeStructAttrAttribute(DefaultClusterCallback callback, ChipStructs.UnitTestingClusterSimpleStruct value) {
-        writeStructAttrAttribute(chipClusterPtr, callback, value, null);
+    public void writeInt24uAttribute(DefaultClusterCallback callback, Long value) {
+      writeInt24uAttribute(callback, value, 0);
     }
 
-    public void writeStructAttrAttribute(DefaultClusterCallback callback, ChipStructs.UnitTestingClusterSimpleStruct value, int timedWriteTimeoutMs) {
-        writeStructAttrAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void writeInt24uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), INT24U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void subscribeStructAttrAttribute(
-        StructAttrAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeStructAttrAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+    public void subscribeInt24uAttribute(
+        LongAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT24U_ATTRIBUTE_ID);
 
-    public void readRangeRestrictedInt8uAttribute(
-        IntegerAttributeCallback callback) {
-        readRangeRestrictedInt8uAttribute(chipClusterPtr, callback);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INT24U_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void writeRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value) {
-        writeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, null);
-    }
+    public void readInt32uAttribute(
+        LongAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT32U_ATTRIBUTE_ID);
 
-    public void writeRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INT32U_ATTRIBUTE_ID, true);
     }
 
-    public void subscribeRangeRestrictedInt8uAttribute(
-        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void writeInt32uAttribute(DefaultClusterCallback callback, Long value) {
+      writeInt32uAttribute(callback, value, 0);
     }
 
-    public void readRangeRestrictedInt8sAttribute(
-        IntegerAttributeCallback callback) {
-        readRangeRestrictedInt8sAttribute(chipClusterPtr, callback);
+    public void writeInt32uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), INT32U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void writeRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value) {
-        writeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, null);
-    }
+    public void subscribeInt32uAttribute(
+        LongAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT32U_ATTRIBUTE_ID);
 
-    public void writeRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INT32U_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void subscribeRangeRestrictedInt8sAttribute(
-        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+    public void readInt40uAttribute(
+        LongAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT40U_ATTRIBUTE_ID);
 
-    public void readRangeRestrictedInt16uAttribute(
-        IntegerAttributeCallback callback) {
-        readRangeRestrictedInt16uAttribute(chipClusterPtr, callback);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INT40U_ATTRIBUTE_ID, true);
     }
 
-    public void writeRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value) {
-        writeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, null);
+    public void writeInt40uAttribute(DefaultClusterCallback callback, Long value) {
+      writeInt40uAttribute(callback, value, 0);
     }
 
-    public void writeRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void writeInt40uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), INT40U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void subscribeRangeRestrictedInt16uAttribute(
-        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+    public void subscribeInt40uAttribute(
+        LongAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT40U_ATTRIBUTE_ID);
 
-    public void readRangeRestrictedInt16sAttribute(
-        IntegerAttributeCallback callback) {
-        readRangeRestrictedInt16sAttribute(chipClusterPtr, callback);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INT40U_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void writeRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value) {
-        writeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, null);
+    public void readInt48uAttribute(
+        LongAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT48U_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INT48U_ATTRIBUTE_ID, true);
     }
 
-    public void writeRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void writeInt48uAttribute(DefaultClusterCallback callback, Long value) {
+      writeInt48uAttribute(callback, value, 0);
     }
 
-    public void subscribeRangeRestrictedInt16sAttribute(
-        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void writeInt48uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), INT48U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void readListLongOctetStringAttribute(
-        ListLongOctetStringAttributeCallback callback) {
-        readListLongOctetStringAttribute(chipClusterPtr, callback);
-    }
+    public void subscribeInt48uAttribute(
+        LongAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT48U_ATTRIBUTE_ID);
 
-    public void writeListLongOctetStringAttribute(DefaultClusterCallback callback, ArrayList<byte[]> value) {
-        writeListLongOctetStringAttribute(chipClusterPtr, callback, value, null);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INT48U_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void writeListLongOctetStringAttribute(DefaultClusterCallback callback, ArrayList<byte[]> value, int timedWriteTimeoutMs) {
-        writeListLongOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
+    public void readInt56uAttribute(
+        LongAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT56U_ATTRIBUTE_ID);
 
-    public void subscribeListLongOctetStringAttribute(
-        ListLongOctetStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeListLongOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INT56U_ATTRIBUTE_ID, true);
     }
 
-    public void readListFabricScopedAttribute(
-        ListFabricScopedAttributeCallback callback) {
-        readListFabricScopedAttribute(chipClusterPtr, callback, true);
+    public void writeInt56uAttribute(DefaultClusterCallback callback, Long value) {
+      writeInt56uAttribute(callback, value, 0);
     }
 
-    public void readListFabricScopedAttributeWithFabricFilter(
-        ListFabricScopedAttributeCallback callback, boolean isFabricFiltered) {
-        readListFabricScopedAttribute(chipClusterPtr, callback, isFabricFiltered);
+    public void writeInt56uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), INT56U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
+    public void subscribeInt56uAttribute(
+        LongAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT56U_ATTRIBUTE_ID);
 
-    public void writeListFabricScopedAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.UnitTestingClusterTestFabricScoped> value) {
-        writeListFabricScopedAttribute(chipClusterPtr, callback, value, null);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INT56U_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void writeListFabricScopedAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.UnitTestingClusterTestFabricScoped> value, int timedWriteTimeoutMs) {
-        writeListFabricScopedAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
+    public void readInt64uAttribute(
+        LongAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT64U_ATTRIBUTE_ID);
 
-    public void subscribeListFabricScopedAttribute(
-        ListFabricScopedAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeListFabricScopedAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INT64U_ATTRIBUTE_ID, true);
     }
 
-    public void readTimedWriteBooleanAttribute(
-        BooleanAttributeCallback callback) {
-        readTimedWriteBooleanAttribute(chipClusterPtr, callback);
+    public void writeInt64uAttribute(DefaultClusterCallback callback, Long value) {
+      writeInt64uAttribute(callback, value, 0);
     }
 
-    public void writeTimedWriteBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
-        writeTimedWriteBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void writeInt64uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), INT64U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void subscribeTimedWriteBooleanAttribute(
-        BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeTimedWriteBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+    public void subscribeInt64uAttribute(
+        LongAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT64U_ATTRIBUTE_ID);
 
-    public void readGeneralErrorBooleanAttribute(
-        BooleanAttributeCallback callback) {
-        readGeneralErrorBooleanAttribute(chipClusterPtr, callback);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INT64U_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void writeGeneralErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value) {
-        writeGeneralErrorBooleanAttribute(chipClusterPtr, callback, value, null);
-    }
+    public void readInt8sAttribute(
+        IntegerAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT8S_ATTRIBUTE_ID);
 
-    public void writeGeneralErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
-        writeGeneralErrorBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INT8S_ATTRIBUTE_ID, true);
     }
 
-    public void subscribeGeneralErrorBooleanAttribute(
-        BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneralErrorBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void writeInt8sAttribute(DefaultClusterCallback callback, Integer value) {
+      writeInt8sAttribute(callback, value, 0);
     }
 
-    public void readClusterErrorBooleanAttribute(
-        BooleanAttributeCallback callback) {
-        readClusterErrorBooleanAttribute(chipClusterPtr, callback);
+    public void writeInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new IntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), INT8S_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void writeClusterErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value) {
-        writeClusterErrorBooleanAttribute(chipClusterPtr, callback, value, null);
-    }
+    public void subscribeInt8sAttribute(
+        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT8S_ATTRIBUTE_ID);
 
-    public void writeClusterErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
-        writeClusterErrorBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INT8S_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void subscribeClusterErrorBooleanAttribute(
-        BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterErrorBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+    public void readInt16sAttribute(
+        IntegerAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT16S_ATTRIBUTE_ID);
 
-    public void readUnsupportedAttribute(
-        BooleanAttributeCallback callback) {
-        readUnsupportedAttribute(chipClusterPtr, callback);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INT16S_ATTRIBUTE_ID, true);
     }
 
-    public void writeUnsupportedAttribute(DefaultClusterCallback callback, Boolean value) {
-        writeUnsupportedAttribute(chipClusterPtr, callback, value, null);
+    public void writeInt16sAttribute(DefaultClusterCallback callback, Integer value) {
+      writeInt16sAttribute(callback, value, 0);
     }
 
-    public void writeUnsupportedAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
-        writeUnsupportedAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void writeInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new IntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), INT16S_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void subscribeUnsupportedAttribute(
-        BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeUnsupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+    public void subscribeInt16sAttribute(
+        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT16S_ATTRIBUTE_ID);
 
-    public void readNullableBooleanAttribute(
-        NullableBooleanAttributeCallback callback) {
-        readNullableBooleanAttribute(chipClusterPtr, callback);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INT16S_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void writeNullableBooleanAttribute(DefaultClusterCallback callback, Boolean value) {
-        writeNullableBooleanAttribute(chipClusterPtr, callback, value, null);
-    }
+    public void readInt24sAttribute(
+        LongAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT24S_ATTRIBUTE_ID);
 
-    public void writeNullableBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
-        writeNullableBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INT24S_ATTRIBUTE_ID, true);
     }
 
-    public void subscribeNullableBooleanAttribute(
-        NullableBooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void writeInt24sAttribute(DefaultClusterCallback callback, Long value) {
+      writeInt24sAttribute(callback, value, 0);
     }
 
-    public void readNullableBitmap8Attribute(
-        NullableBitmap8AttributeCallback callback) {
-        readNullableBitmap8Attribute(chipClusterPtr, callback);
+    public void writeInt24sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new IntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), INT24S_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void writeNullableBitmap8Attribute(DefaultClusterCallback callback, Integer value) {
-        writeNullableBitmap8Attribute(chipClusterPtr, callback, value, null);
-    }
+    public void subscribeInt24sAttribute(
+        LongAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT24S_ATTRIBUTE_ID);
 
-    public void writeNullableBitmap8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeNullableBitmap8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INT24S_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void subscribeNullableBitmap8Attribute(
-        NullableBitmap8AttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableBitmap8Attribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+    public void readInt32sAttribute(
+        LongAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT32S_ATTRIBUTE_ID);
 
-    public void readNullableBitmap16Attribute(
-        NullableBitmap16AttributeCallback callback) {
-        readNullableBitmap16Attribute(chipClusterPtr, callback);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INT32S_ATTRIBUTE_ID, true);
     }
 
-    public void writeNullableBitmap16Attribute(DefaultClusterCallback callback, Integer value) {
-        writeNullableBitmap16Attribute(chipClusterPtr, callback, value, null);
+    public void writeInt32sAttribute(DefaultClusterCallback callback, Long value) {
+      writeInt32sAttribute(callback, value, 0);
     }
 
-    public void writeNullableBitmap16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeNullableBitmap16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void writeInt32sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new IntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), INT32S_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void subscribeNullableBitmap16Attribute(
-        NullableBitmap16AttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableBitmap16Attribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+    public void subscribeInt32sAttribute(
+        LongAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT32S_ATTRIBUTE_ID);
 
-    public void readNullableBitmap32Attribute(
-        NullableBitmap32AttributeCallback callback) {
-        readNullableBitmap32Attribute(chipClusterPtr, callback);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INT32S_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void writeNullableBitmap32Attribute(DefaultClusterCallback callback, Long value) {
-        writeNullableBitmap32Attribute(chipClusterPtr, callback, value, null);
-    }
+    public void readInt40sAttribute(
+        LongAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT40S_ATTRIBUTE_ID);
 
-    public void writeNullableBitmap32Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeNullableBitmap32Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INT40S_ATTRIBUTE_ID, true);
     }
 
-    public void subscribeNullableBitmap32Attribute(
-        NullableBitmap32AttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableBitmap32Attribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void writeInt40sAttribute(DefaultClusterCallback callback, Long value) {
+      writeInt40sAttribute(callback, value, 0);
     }
 
-    public void readNullableBitmap64Attribute(
-        NullableBitmap64AttributeCallback callback) {
-        readNullableBitmap64Attribute(chipClusterPtr, callback);
+    public void writeInt40sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new IntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), INT40S_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void writeNullableBitmap64Attribute(DefaultClusterCallback callback, Long value) {
-        writeNullableBitmap64Attribute(chipClusterPtr, callback, value, null);
-    }
+    public void subscribeInt40sAttribute(
+        LongAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT40S_ATTRIBUTE_ID);
 
-    public void writeNullableBitmap64Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeNullableBitmap64Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INT40S_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void subscribeNullableBitmap64Attribute(
-        NullableBitmap64AttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableBitmap64Attribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+    public void readInt48sAttribute(
+        LongAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT48S_ATTRIBUTE_ID);
 
-    public void readNullableInt8uAttribute(
-        NullableInt8uAttributeCallback callback) {
-        readNullableInt8uAttribute(chipClusterPtr, callback);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INT48S_ATTRIBUTE_ID, true);
     }
 
-    public void writeNullableInt8uAttribute(DefaultClusterCallback callback, Integer value) {
-        writeNullableInt8uAttribute(chipClusterPtr, callback, value, null);
+    public void writeInt48sAttribute(DefaultClusterCallback callback, Long value) {
+      writeInt48sAttribute(callback, value, 0);
     }
 
-    public void writeNullableInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeNullableInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void writeInt48sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new IntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), INT48S_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void subscribeNullableInt8uAttribute(
-        NullableInt8uAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+    public void subscribeInt48sAttribute(
+        LongAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT48S_ATTRIBUTE_ID);
 
-    public void readNullableInt16uAttribute(
-        NullableInt16uAttributeCallback callback) {
-        readNullableInt16uAttribute(chipClusterPtr, callback);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INT48S_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void writeNullableInt16uAttribute(DefaultClusterCallback callback, Integer value) {
-        writeNullableInt16uAttribute(chipClusterPtr, callback, value, null);
-    }
+    public void readInt56sAttribute(
+        LongAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT56S_ATTRIBUTE_ID);
 
-    public void writeNullableInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeNullableInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INT56S_ATTRIBUTE_ID, true);
     }
 
-    public void subscribeNullableInt16uAttribute(
-        NullableInt16uAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void writeInt56sAttribute(DefaultClusterCallback callback, Long value) {
+      writeInt56sAttribute(callback, value, 0);
     }
 
-    public void readNullableInt24uAttribute(
-        NullableInt24uAttributeCallback callback) {
-        readNullableInt24uAttribute(chipClusterPtr, callback);
+    public void writeInt56sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new IntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), INT56S_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void writeNullableInt24uAttribute(DefaultClusterCallback callback, Long value) {
-        writeNullableInt24uAttribute(chipClusterPtr, callback, value, null);
-    }
+    public void subscribeInt56sAttribute(
+        LongAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT56S_ATTRIBUTE_ID);
 
-    public void writeNullableInt24uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeNullableInt24uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INT56S_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void subscribeNullableInt24uAttribute(
-        NullableInt24uAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableInt24uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+    public void readInt64sAttribute(
+        LongAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT64S_ATTRIBUTE_ID);
 
-    public void readNullableInt32uAttribute(
-        NullableInt32uAttributeCallback callback) {
-        readNullableInt32uAttribute(chipClusterPtr, callback);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, INT64S_ATTRIBUTE_ID, true);
     }
 
-    public void writeNullableInt32uAttribute(DefaultClusterCallback callback, Long value) {
-        writeNullableInt32uAttribute(chipClusterPtr, callback, value, null);
+    public void writeInt64sAttribute(DefaultClusterCallback callback, Long value) {
+      writeInt64sAttribute(callback, value, 0);
     }
 
-    public void writeNullableInt32uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeNullableInt32uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void writeInt64sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new IntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), INT64S_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void subscribeNullableInt32uAttribute(
-        NullableInt32uAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableInt32uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+    public void subscribeInt64sAttribute(
+        LongAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, INT64S_ATTRIBUTE_ID);
 
-    public void readNullableInt40uAttribute(
-        NullableInt40uAttributeCallback callback) {
-        readNullableInt40uAttribute(chipClusterPtr, callback);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, INT64S_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void writeNullableInt40uAttribute(DefaultClusterCallback callback, Long value) {
-        writeNullableInt40uAttribute(chipClusterPtr, callback, value, null);
-    }
+    public void readEnum8Attribute(
+        IntegerAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENUM8_ATTRIBUTE_ID);
 
-    public void writeNullableInt40uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeNullableInt40uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ENUM8_ATTRIBUTE_ID, true);
     }
 
-    public void subscribeNullableInt40uAttribute(
-        NullableInt40uAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableInt40uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void writeEnum8Attribute(DefaultClusterCallback callback, Integer value) {
+      writeEnum8Attribute(callback, value, 0);
     }
 
-    public void readNullableInt48uAttribute(
-        NullableInt48uAttributeCallback callback) {
-        readNullableInt48uAttribute(chipClusterPtr, callback);
+    public void writeEnum8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ENUM8_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void writeNullableInt48uAttribute(DefaultClusterCallback callback, Long value) {
-        writeNullableInt48uAttribute(chipClusterPtr, callback, value, null);
-    }
+    public void subscribeEnum8Attribute(
+        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENUM8_ATTRIBUTE_ID);
 
-    public void writeNullableInt48uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeNullableInt48uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ENUM8_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void subscribeNullableInt48uAttribute(
-        NullableInt48uAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableInt48uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void readEnum16Attribute(
+        IntegerAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENUM16_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ENUM16_ATTRIBUTE_ID, true);
     }
 
-    public void readNullableInt56uAttribute(
-        NullableInt56uAttributeCallback callback) {
-        readNullableInt56uAttribute(chipClusterPtr, callback);
+    public void writeEnum16Attribute(DefaultClusterCallback callback, Integer value) {
+      writeEnum16Attribute(callback, value, 0);
     }
 
-    public void writeNullableInt56uAttribute(DefaultClusterCallback callback, Long value) {
-        writeNullableInt56uAttribute(chipClusterPtr, callback, value, null);
+    public void writeEnum16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ENUM16_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void writeNullableInt56uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeNullableInt56uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void subscribeEnum16Attribute(
+        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENUM16_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ENUM16_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void subscribeNullableInt56uAttribute(
-        NullableInt56uAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableInt56uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void readFloatSingleAttribute(
+        FloatAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FLOAT_SINGLE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FLOAT_SINGLE_ATTRIBUTE_ID, true);
     }
 
-    public void readNullableInt64uAttribute(
-        NullableInt64uAttributeCallback callback) {
-        readNullableInt64uAttribute(chipClusterPtr, callback);
+    public void writeFloatSingleAttribute(DefaultClusterCallback callback, Float value) {
+      writeFloatSingleAttribute(callback, value, 0);
     }
 
-    public void writeNullableInt64uAttribute(DefaultClusterCallback callback, Long value) {
-        writeNullableInt64uAttribute(chipClusterPtr, callback, value, null);
+    public void writeFloatSingleAttribute(DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new FloatType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), FLOAT_SINGLE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void writeNullableInt64uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeNullableInt64uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void subscribeFloatSingleAttribute(
+        FloatAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FLOAT_SINGLE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FLOAT_SINGLE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void subscribeNullableInt64uAttribute(
-        NullableInt64uAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableInt64uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void readFloatDoubleAttribute(
+        DoubleAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FLOAT_DOUBLE_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Double value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FLOAT_DOUBLE_ATTRIBUTE_ID, true);
     }
 
-    public void readNullableInt8sAttribute(
-        NullableInt8sAttributeCallback callback) {
-        readNullableInt8sAttribute(chipClusterPtr, callback);
+    public void writeFloatDoubleAttribute(DefaultClusterCallback callback, Double value) {
+      writeFloatDoubleAttribute(callback, value, 0);
     }
 
-    public void writeNullableInt8sAttribute(DefaultClusterCallback callback, Integer value) {
-        writeNullableInt8sAttribute(chipClusterPtr, callback, value, null);
+    public void writeFloatDoubleAttribute(DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new DoubleType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), FLOAT_DOUBLE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void writeNullableInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeNullableInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void subscribeFloatDoubleAttribute(
+        DoubleAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FLOAT_DOUBLE_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Double value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FLOAT_DOUBLE_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void subscribeNullableInt8sAttribute(
-        NullableInt8sAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void readOctetStringAttribute(
+        OctetStringAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OCTET_STRING_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            byte[] value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, OCTET_STRING_ATTRIBUTE_ID, true);
     }
 
-    public void readNullableInt16sAttribute(
-        NullableInt16sAttributeCallback callback) {
-        readNullableInt16sAttribute(chipClusterPtr, callback);
+    public void writeOctetStringAttribute(DefaultClusterCallback callback, byte[] value) {
+      writeOctetStringAttribute(callback, value, 0);
     }
 
-    public void writeNullableInt16sAttribute(DefaultClusterCallback callback, Integer value) {
-        writeNullableInt16sAttribute(chipClusterPtr, callback, value, null);
+    public void writeOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new ByteArrayType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), OCTET_STRING_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void writeNullableInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeNullableInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void subscribeOctetStringAttribute(
+        OctetStringAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, OCTET_STRING_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            byte[] value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, OCTET_STRING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void subscribeNullableInt16sAttribute(
-        NullableInt16sAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void readListInt8uAttribute(
+        ListInt8uAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LIST_INT8U_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LIST_INT8U_ATTRIBUTE_ID, true);
     }
 
-    public void readNullableInt24sAttribute(
-        NullableInt24sAttributeCallback callback) {
-        readNullableInt24sAttribute(chipClusterPtr, callback);
+    public void writeListInt8uAttribute(DefaultClusterCallback callback, ArrayList<Integer> value) {
+      writeListInt8uAttribute(callback, value, 0);
     }
 
-    public void writeNullableInt24sAttribute(DefaultClusterCallback callback, Long value) {
-        writeNullableInt24sAttribute(chipClusterPtr, callback, value, null);
+    public void writeListInt8uAttribute(DefaultClusterCallback callback, ArrayList<Integer> value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = ArrayType.generateArrayType(value, (elementvalue) -> new UIntType(elementvalue));
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LIST_INT8U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void writeNullableInt24sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeNullableInt24sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
+    public void subscribeListInt8uAttribute(
+        ListInt8uAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LIST_INT8U_ATTRIBUTE_ID);
 
-    public void subscribeNullableInt24sAttribute(
-        NullableInt24sAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableInt24sAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Integer> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LIST_INT8U_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void readNullableInt32sAttribute(
-        NullableInt32sAttributeCallback callback) {
-        readNullableInt32sAttribute(chipClusterPtr, callback);
-    }
+    public void readListOctetStringAttribute(
+        ListOctetStringAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LIST_OCTET_STRING_ATTRIBUTE_ID);
 
-    public void writeNullableInt32sAttribute(DefaultClusterCallback callback, Long value) {
-        writeNullableInt32sAttribute(chipClusterPtr, callback, value, null);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<byte[]> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LIST_OCTET_STRING_ATTRIBUTE_ID, true);
     }
 
-    public void writeNullableInt32sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeNullableInt32sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void writeListOctetStringAttribute(DefaultClusterCallback callback, ArrayList<byte[]> value) {
+      writeListOctetStringAttribute(callback, value, 0);
     }
 
-    public void subscribeNullableInt32sAttribute(
-        NullableInt32sAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableInt32sAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void writeListOctetStringAttribute(DefaultClusterCallback callback, ArrayList<byte[]> value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = ArrayType.generateArrayType(value, (elementvalue) -> new ByteArrayType(elementvalue));
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LIST_OCTET_STRING_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void readNullableInt40sAttribute(
-        NullableInt40sAttributeCallback callback) {
-        readNullableInt40sAttribute(chipClusterPtr, callback);
-    }
+    public void subscribeListOctetStringAttribute(
+        ListOctetStringAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LIST_OCTET_STRING_ATTRIBUTE_ID);
 
-    public void writeNullableInt40sAttribute(DefaultClusterCallback callback, Long value) {
-        writeNullableInt40sAttribute(chipClusterPtr, callback, value, null);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<byte[]> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LIST_OCTET_STRING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void writeNullableInt40sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeNullableInt40sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
+    public void readListStructOctetStringAttribute(
+        ListStructOctetStringAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LIST_STRUCT_OCTET_STRING_ATTRIBUTE_ID);
 
-    public void subscribeNullableInt40sAttribute(
-        NullableInt40sAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableInt40sAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.UnitTestingClusterTestListStructOctet> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LIST_STRUCT_OCTET_STRING_ATTRIBUTE_ID, true);
     }
 
-    public void readNullableInt48sAttribute(
-        NullableInt48sAttributeCallback callback) {
-        readNullableInt48sAttribute(chipClusterPtr, callback);
+    public void writeListStructOctetStringAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.UnitTestingClusterTestListStructOctet> value) {
+      writeListStructOctetStringAttribute(callback, value, 0);
     }
 
-    public void writeNullableInt48sAttribute(DefaultClusterCallback callback, Long value) {
-        writeNullableInt48sAttribute(chipClusterPtr, callback, value, null);
+    public void writeListStructOctetStringAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.UnitTestingClusterTestListStructOctet> value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = ArrayType.generateArrayType(value, (elementvalue) -> elementvalue.encodeTlv());
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LIST_STRUCT_OCTET_STRING_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void writeNullableInt48sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeNullableInt48sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
+    public void subscribeListStructOctetStringAttribute(
+        ListStructOctetStringAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LIST_STRUCT_OCTET_STRING_ATTRIBUTE_ID);
 
-    public void subscribeNullableInt48sAttribute(
-        NullableInt48sAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableInt48sAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.UnitTestingClusterTestListStructOctet> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LIST_STRUCT_OCTET_STRING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void readNullableInt56sAttribute(
-        NullableInt56sAttributeCallback callback) {
-        readNullableInt56sAttribute(chipClusterPtr, callback);
-    }
+    public void readLongOctetStringAttribute(
+        OctetStringAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LONG_OCTET_STRING_ATTRIBUTE_ID);
 
-    public void writeNullableInt56sAttribute(DefaultClusterCallback callback, Long value) {
-        writeNullableInt56sAttribute(chipClusterPtr, callback, value, null);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            byte[] value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LONG_OCTET_STRING_ATTRIBUTE_ID, true);
     }
 
-    public void writeNullableInt56sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeNullableInt56sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void writeLongOctetStringAttribute(DefaultClusterCallback callback, byte[] value) {
+      writeLongOctetStringAttribute(callback, value, 0);
     }
 
-    public void subscribeNullableInt56sAttribute(
-        NullableInt56sAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableInt56sAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void writeLongOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new ByteArrayType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LONG_OCTET_STRING_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void readNullableInt64sAttribute(
-        NullableInt64sAttributeCallback callback) {
-        readNullableInt64sAttribute(chipClusterPtr, callback);
-    }
+    public void subscribeLongOctetStringAttribute(
+        OctetStringAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LONG_OCTET_STRING_ATTRIBUTE_ID);
 
-    public void writeNullableInt64sAttribute(DefaultClusterCallback callback, Long value) {
-        writeNullableInt64sAttribute(chipClusterPtr, callback, value, null);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            byte[] value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LONG_OCTET_STRING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void writeNullableInt64sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
-        writeNullableInt64sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
+    public void readCharStringAttribute(
+        CharStringAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CHAR_STRING_ATTRIBUTE_ID);
 
-    public void subscribeNullableInt64sAttribute(
-        NullableInt64sAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableInt64sAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CHAR_STRING_ATTRIBUTE_ID, true);
     }
 
-    public void readNullableEnum8Attribute(
-        NullableEnum8AttributeCallback callback) {
-        readNullableEnum8Attribute(chipClusterPtr, callback);
+    public void writeCharStringAttribute(DefaultClusterCallback callback, String value) {
+      writeCharStringAttribute(callback, value, 0);
     }
 
-    public void writeNullableEnum8Attribute(DefaultClusterCallback callback, Integer value) {
-        writeNullableEnum8Attribute(chipClusterPtr, callback, value, null);
+    public void writeCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new StringType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), CHAR_STRING_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void writeNullableEnum8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeNullableEnum8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
+    public void subscribeCharStringAttribute(
+        CharStringAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CHAR_STRING_ATTRIBUTE_ID);
 
-    public void subscribeNullableEnum8Attribute(
-        NullableEnum8AttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableEnum8Attribute(chipClusterPtr, callback, minInterval, maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CHAR_STRING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void readNullableEnum16Attribute(
-        NullableEnum16AttributeCallback callback) {
-        readNullableEnum16Attribute(chipClusterPtr, callback);
-    }
+    public void readLongCharStringAttribute(
+        CharStringAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LONG_CHAR_STRING_ATTRIBUTE_ID);
 
-    public void writeNullableEnum16Attribute(DefaultClusterCallback callback, Integer value) {
-        writeNullableEnum16Attribute(chipClusterPtr, callback, value, null);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LONG_CHAR_STRING_ATTRIBUTE_ID, true);
     }
 
-    public void writeNullableEnum16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeNullableEnum16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void writeLongCharStringAttribute(DefaultClusterCallback callback, String value) {
+      writeLongCharStringAttribute(callback, value, 0);
     }
 
-    public void subscribeNullableEnum16Attribute(
-        NullableEnum16AttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableEnum16Attribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void writeLongCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new StringType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LONG_CHAR_STRING_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void readNullableFloatSingleAttribute(
-        NullableFloatSingleAttributeCallback callback) {
-        readNullableFloatSingleAttribute(chipClusterPtr, callback);
-    }
+    public void subscribeLongCharStringAttribute(
+        CharStringAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LONG_CHAR_STRING_ATTRIBUTE_ID);
 
-    public void writeNullableFloatSingleAttribute(DefaultClusterCallback callback, Float value) {
-        writeNullableFloatSingleAttribute(chipClusterPtr, callback, value, null);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LONG_CHAR_STRING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void writeNullableFloatSingleAttribute(DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) {
-        writeNullableFloatSingleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
+    public void readEpochUsAttribute(
+        LongAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EPOCH_US_ATTRIBUTE_ID);
 
-    public void subscribeNullableFloatSingleAttribute(
-        NullableFloatSingleAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableFloatSingleAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EPOCH_US_ATTRIBUTE_ID, true);
     }
 
-    public void readNullableFloatDoubleAttribute(
-        NullableFloatDoubleAttributeCallback callback) {
-        readNullableFloatDoubleAttribute(chipClusterPtr, callback);
+    public void writeEpochUsAttribute(DefaultClusterCallback callback, Long value) {
+      writeEpochUsAttribute(callback, value, 0);
     }
 
-    public void writeNullableFloatDoubleAttribute(DefaultClusterCallback callback, Double value) {
-        writeNullableFloatDoubleAttribute(chipClusterPtr, callback, value, null);
+    public void writeEpochUsAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), EPOCH_US_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void writeNullableFloatDoubleAttribute(DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) {
-        writeNullableFloatDoubleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
+    public void subscribeEpochUsAttribute(
+        LongAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EPOCH_US_ATTRIBUTE_ID);
 
-    public void subscribeNullableFloatDoubleAttribute(
-        NullableFloatDoubleAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableFloatDoubleAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EPOCH_US_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void readNullableOctetStringAttribute(
-        NullableOctetStringAttributeCallback callback) {
-        readNullableOctetStringAttribute(chipClusterPtr, callback);
-    }
+    public void readEpochSAttribute(
+        LongAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EPOCH_S_ATTRIBUTE_ID);
 
-    public void writeNullableOctetStringAttribute(DefaultClusterCallback callback, byte[] value) {
-        writeNullableOctetStringAttribute(chipClusterPtr, callback, value, null);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EPOCH_S_ATTRIBUTE_ID, true);
     }
 
-    public void writeNullableOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) {
-        writeNullableOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void writeEpochSAttribute(DefaultClusterCallback callback, Long value) {
+      writeEpochSAttribute(callback, value, 0);
     }
 
-    public void subscribeNullableOctetStringAttribute(
-        NullableOctetStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void writeEpochSAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), EPOCH_S_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void readNullableCharStringAttribute(
-        NullableCharStringAttributeCallback callback) {
-        readNullableCharStringAttribute(chipClusterPtr, callback);
-    }
+    public void subscribeEpochSAttribute(
+        LongAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EPOCH_S_ATTRIBUTE_ID);
 
-    public void writeNullableCharStringAttribute(DefaultClusterCallback callback, String value) {
-        writeNullableCharStringAttribute(chipClusterPtr, callback, value, null);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EPOCH_S_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void writeNullableCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) {
-        writeNullableCharStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
+    public void readVendorIdAttribute(
+        IntegerAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, VENDOR_ID_ATTRIBUTE_ID);
 
-    public void subscribeNullableCharStringAttribute(
-        NullableCharStringAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableCharStringAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, VENDOR_ID_ATTRIBUTE_ID, true);
     }
 
-    public void readNullableEnumAttrAttribute(
-        NullableEnumAttrAttributeCallback callback) {
-        readNullableEnumAttrAttribute(chipClusterPtr, callback);
+    public void writeVendorIdAttribute(DefaultClusterCallback callback, Integer value) {
+      writeVendorIdAttribute(callback, value, 0);
     }
 
-    public void writeNullableEnumAttrAttribute(DefaultClusterCallback callback, Integer value) {
-        writeNullableEnumAttrAttribute(chipClusterPtr, callback, value, null);
+    public void writeVendorIdAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), VENDOR_ID_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void writeNullableEnumAttrAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeNullableEnumAttrAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
+    public void subscribeVendorIdAttribute(
+        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, VENDOR_ID_ATTRIBUTE_ID);
 
-    public void subscribeNullableEnumAttrAttribute(
-        NullableEnumAttrAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableEnumAttrAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, VENDOR_ID_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void readNullableStructAttribute(
-        NullableStructAttributeCallback callback) {
-        readNullableStructAttribute(chipClusterPtr, callback);
-    }
+    public void readListNullablesAndOptionalsStructAttribute(
+        ListNullablesAndOptionalsStructAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LIST_NULLABLES_AND_OPTIONALS_STRUCT_ATTRIBUTE_ID);
 
-    public void writeNullableStructAttribute(DefaultClusterCallback callback, ChipStructs.UnitTestingClusterSimpleStruct value) {
-        writeNullableStructAttribute(chipClusterPtr, callback, value, null);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.UnitTestingClusterNullablesAndOptionalsStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LIST_NULLABLES_AND_OPTIONALS_STRUCT_ATTRIBUTE_ID, true);
     }
 
-    public void writeNullableStructAttribute(DefaultClusterCallback callback, ChipStructs.UnitTestingClusterSimpleStruct value, int timedWriteTimeoutMs) {
-        writeNullableStructAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void writeListNullablesAndOptionalsStructAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.UnitTestingClusterNullablesAndOptionalsStruct> value) {
+      writeListNullablesAndOptionalsStructAttribute(callback, value, 0);
     }
 
-    public void subscribeNullableStructAttribute(
-        NullableStructAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableStructAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void writeListNullablesAndOptionalsStructAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.UnitTestingClusterNullablesAndOptionalsStruct> value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = ArrayType.generateArrayType(value, (elementvalue) -> elementvalue.encodeTlv());
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LIST_NULLABLES_AND_OPTIONALS_STRUCT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void readNullableRangeRestrictedInt8uAttribute(
-        NullableRangeRestrictedInt8uAttributeCallback callback) {
-        readNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback);
-    }
+    public void subscribeListNullablesAndOptionalsStructAttribute(
+        ListNullablesAndOptionalsStructAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LIST_NULLABLES_AND_OPTIONALS_STRUCT_ATTRIBUTE_ID);
 
-    public void writeNullableRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value) {
-        writeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, null);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.UnitTestingClusterNullablesAndOptionalsStruct> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LIST_NULLABLES_AND_OPTIONALS_STRUCT_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void writeNullableRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
+    public void readEnumAttrAttribute(
+        IntegerAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENUM_ATTR_ATTRIBUTE_ID);
 
-    public void subscribeNullableRangeRestrictedInt8uAttribute(
-        NullableRangeRestrictedInt8uAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ENUM_ATTR_ATTRIBUTE_ID, true);
     }
 
-    public void readNullableRangeRestrictedInt8sAttribute(
-        NullableRangeRestrictedInt8sAttributeCallback callback) {
-        readNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback);
+    public void writeEnumAttrAttribute(DefaultClusterCallback callback, Integer value) {
+      writeEnumAttrAttribute(callback, value, 0);
     }
 
-    public void writeNullableRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value) {
-        writeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, null);
+    public void writeEnumAttrAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), ENUM_ATTR_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void writeNullableRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
-    }
+    public void subscribeEnumAttrAttribute(
+        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ENUM_ATTR_ATTRIBUTE_ID);
 
-    public void subscribeNullableRangeRestrictedInt8sAttribute(
-        NullableRangeRestrictedInt8sAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ENUM_ATTR_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void readNullableRangeRestrictedInt16uAttribute(
-        NullableRangeRestrictedInt16uAttributeCallback callback) {
-        readNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback);
+    public void readStructAttrAttribute(
+        StructAttrAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STRUCT_ATTR_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            ChipStructs.UnitTestingClusterSimpleStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, STRUCT_ATTR_ATTRIBUTE_ID, true);
     }
 
-    public void writeNullableRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value) {
-        writeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, null);
+    public void writeStructAttrAttribute(DefaultClusterCallback callback, ChipStructs.UnitTestingClusterSimpleStruct value) {
+      writeStructAttrAttribute(callback, value, 0);
     }
 
-    public void writeNullableRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void writeStructAttrAttribute(DefaultClusterCallback callback, ChipStructs.UnitTestingClusterSimpleStruct value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value.encodeTlv();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), STRUCT_ATTR_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void subscribeNullableRangeRestrictedInt16uAttribute(
-        NullableRangeRestrictedInt16uAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void subscribeStructAttrAttribute(
+        StructAttrAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STRUCT_ATTR_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            ChipStructs.UnitTestingClusterSimpleStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, STRUCT_ATTR_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void readNullableRangeRestrictedInt16sAttribute(
-        NullableRangeRestrictedInt16sAttributeCallback callback) {
-        readNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback);
+    public void readRangeRestrictedInt8uAttribute(
+        IntegerAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RANGE_RESTRICTED_INT8U_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RANGE_RESTRICTED_INT8U_ATTRIBUTE_ID, true);
     }
 
-    public void writeNullableRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value) {
-        writeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, null);
+    public void writeRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value) {
+      writeRangeRestrictedInt8uAttribute(callback, value, 0);
     }
 
-    public void writeNullableRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void writeRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), RANGE_RESTRICTED_INT8U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void subscribeNullableRangeRestrictedInt16sAttribute(
-        NullableRangeRestrictedInt16sAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void subscribeRangeRestrictedInt8uAttribute(
+        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RANGE_RESTRICTED_INT8U_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RANGE_RESTRICTED_INT8U_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void readWriteOnlyInt8uAttribute(
+    public void readRangeRestrictedInt8sAttribute(
         IntegerAttributeCallback callback) {
-        readWriteOnlyInt8uAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RANGE_RESTRICTED_INT8S_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RANGE_RESTRICTED_INT8S_ATTRIBUTE_ID, true);
     }
 
-    public void writeWriteOnlyInt8uAttribute(DefaultClusterCallback callback, Integer value) {
-        writeWriteOnlyInt8uAttribute(chipClusterPtr, callback, value, null);
+    public void writeRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value) {
+      writeRangeRestrictedInt8sAttribute(callback, value, 0);
     }
 
-    public void writeWriteOnlyInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
-        writeWriteOnlyInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+    public void writeRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new IntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), RANGE_RESTRICTED_INT8S_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void subscribeWriteOnlyInt8uAttribute(
+    public void subscribeRangeRestrictedInt8sAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeWriteOnlyInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RANGE_RESTRICTED_INT8S_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RANGE_RESTRICTED_INT8S_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void readGeneratedCommandListAttribute(
-        GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+    public void readRangeRestrictedInt16uAttribute(
+        IntegerAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RANGE_RESTRICTED_INT16U_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RANGE_RESTRICTED_INT16U_ATTRIBUTE_ID, true);
     }
 
-    public void subscribeGeneratedCommandListAttribute(
-        GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void writeRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value) {
+      writeRangeRestrictedInt16uAttribute(callback, value, 0);
     }
 
-    public void readAcceptedCommandListAttribute(
-        AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+    public void writeRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), RANGE_RESTRICTED_INT16U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void subscribeAcceptedCommandListAttribute(
-        AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void subscribeRangeRestrictedInt16uAttribute(
+        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RANGE_RESTRICTED_INT16U_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RANGE_RESTRICTED_INT16U_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void readEventListAttribute(
-        EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+    public void readRangeRestrictedInt16sAttribute(
+        IntegerAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RANGE_RESTRICTED_INT16S_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, RANGE_RESTRICTED_INT16S_ATTRIBUTE_ID, true);
     }
 
-    public void subscribeEventListAttribute(
-        EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void writeRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value) {
+      writeRangeRestrictedInt16sAttribute(callback, value, 0);
     }
 
-    public void readAttributeListAttribute(
-        AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+    public void writeRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new IntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), RANGE_RESTRICTED_INT16S_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void subscribeAttributeListAttribute(
-        AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void subscribeRangeRestrictedInt16sAttribute(
+        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RANGE_RESTRICTED_INT16S_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, RANGE_RESTRICTED_INT16S_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    public void readFeatureMapAttribute(
-        LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+    public void readListLongOctetStringAttribute(
+        ListLongOctetStringAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LIST_LONG_OCTET_STRING_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<byte[]> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LIST_LONG_OCTET_STRING_ATTRIBUTE_ID, true);
     }
 
-    public void subscribeFeatureMapAttribute(
-        LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void writeListLongOctetStringAttribute(DefaultClusterCallback callback, ArrayList<byte[]> value) {
+      writeListLongOctetStringAttribute(callback, value, 0);
     }
 
-    public void readClusterRevisionAttribute(
-        IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+    public void writeListLongOctetStringAttribute(DefaultClusterCallback callback, ArrayList<byte[]> value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = ArrayType.generateArrayType(value, (elementvalue) -> new ByteArrayType(elementvalue));
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LIST_LONG_OCTET_STRING_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
-    public void subscribeClusterRevisionAttribute(
-        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+    public void subscribeListLongOctetStringAttribute(
+        ListLongOctetStringAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LIST_LONG_OCTET_STRING_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<byte[]> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LIST_LONG_OCTET_STRING_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
-    private native void readBooleanAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
+    public void readListFabricScopedAttribute(
+        ListFabricScopedAttributeCallback callback) {
+      readListFabricScopedAttributeWithFabricFilter(callback, true);
+    }
 
-    private native void writeBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs);
+    public void readListFabricScopedAttributeWithFabricFilter(
+        ListFabricScopedAttributeCallback callback, boolean isFabricFiltered) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LIST_FABRIC_SCOPED_ATTRIBUTE_ID);
 
-    private native void subscribeBooleanAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.UnitTestingClusterTestFabricScoped> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, LIST_FABRIC_SCOPED_ATTRIBUTE_ID, isFabricFiltered);
+    }
 
-    private native void readBitmap8Attribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void writeListFabricScopedAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.UnitTestingClusterTestFabricScoped> value) {
+      writeListFabricScopedAttribute(callback, value, 0);
+    }
 
-    private native void writeBitmap8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    public void writeListFabricScopedAttribute(DefaultClusterCallback callback, ArrayList<ChipStructs.UnitTestingClusterTestFabricScoped> value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = ArrayType.generateArrayType(value, (elementvalue) -> elementvalue.encodeTlv());
+      writeAttribute(new WriteAttributesCallbackImpl(callback), LIST_FABRIC_SCOPED_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void subscribeBitmap8Attribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void subscribeListFabricScopedAttribute(
+        ListFabricScopedAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, LIST_FABRIC_SCOPED_ATTRIBUTE_ID);
 
-    private native void readBitmap16Attribute(long chipClusterPtr, IntegerAttributeCallback callback);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<ChipStructs.UnitTestingClusterTestFabricScoped> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, LIST_FABRIC_SCOPED_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void writeBitmap16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    public void readTimedWriteBooleanAttribute(
+        BooleanAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TIMED_WRITE_BOOLEAN_ATTRIBUTE_ID);
 
-    private native void subscribeBitmap16Attribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, TIMED_WRITE_BOOLEAN_ATTRIBUTE_ID, true);
+    }
 
-    private native void readBitmap32Attribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void writeTimedWriteBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new BooleanType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), TIMED_WRITE_BOOLEAN_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeBitmap32Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeTimedWriteBooleanAttribute(
+        BooleanAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, TIMED_WRITE_BOOLEAN_ATTRIBUTE_ID);
 
-    private native void subscribeBitmap32Attribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, TIMED_WRITE_BOOLEAN_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readBitmap64Attribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void readGeneralErrorBooleanAttribute(
+        BooleanAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERAL_ERROR_BOOLEAN_ATTRIBUTE_ID);
 
-    private native void writeBitmap64Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERAL_ERROR_BOOLEAN_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeBitmap64Attribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeGeneralErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value) {
+      writeGeneralErrorBooleanAttribute(callback, value, 0);
+    }
 
-    private native void readInt8uAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void writeGeneralErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new BooleanType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), GENERAL_ERROR_BOOLEAN_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeGeneralErrorBooleanAttribute(
+        BooleanAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERAL_ERROR_BOOLEAN_ATTRIBUTE_ID);
 
-    private native void subscribeInt8uAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERAL_ERROR_BOOLEAN_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readInt16uAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void readClusterErrorBooleanAttribute(
+        BooleanAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_ERROR_BOOLEAN_ATTRIBUTE_ID);
 
-    private native void writeInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_ERROR_BOOLEAN_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeInt16uAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeClusterErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value) {
+      writeClusterErrorBooleanAttribute(callback, value, 0);
+    }
 
-    private native void readInt24uAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void writeClusterErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new BooleanType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), CLUSTER_ERROR_BOOLEAN_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeInt24uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeClusterErrorBooleanAttribute(
+        BooleanAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_ERROR_BOOLEAN_ATTRIBUTE_ID);
 
-    private native void subscribeInt24uAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_ERROR_BOOLEAN_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readInt32uAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void readUnsupportedAttribute(
+        BooleanAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNSUPPORTED_ATTRIBUTE_ID);
 
-    private native void writeInt32uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, UNSUPPORTED_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeInt32uAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeUnsupportedAttribute(DefaultClusterCallback callback, Boolean value) {
+      writeUnsupportedAttribute(callback, value, 0);
+    }
 
-    private native void readInt40uAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void writeUnsupportedAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new BooleanType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), UNSUPPORTED_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeInt40uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeUnsupportedAttribute(
+        BooleanAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, UNSUPPORTED_ATTRIBUTE_ID);
 
-    private native void subscribeInt40uAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, UNSUPPORTED_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readInt48uAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void readNullableBooleanAttribute(
+        NullableBooleanAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_BOOLEAN_ATTRIBUTE_ID);
 
-    private native void writeInt48uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_BOOLEAN_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeInt48uAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableBooleanAttribute(DefaultClusterCallback callback, Boolean value) {
+      writeNullableBooleanAttribute(callback, value, 0);
+    }
 
-    private native void readInt56uAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void writeNullableBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new BooleanType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_BOOLEAN_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeInt56uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableBooleanAttribute(
+        NullableBooleanAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_BOOLEAN_ATTRIBUTE_ID);
 
-    private native void subscribeInt56uAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_BOOLEAN_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readInt64uAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void readNullableBitmap8Attribute(
+        NullableBitmap8AttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_BITMAP8_ATTRIBUTE_ID);
 
-    private native void writeInt64uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_BITMAP8_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeInt64uAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableBitmap8Attribute(DefaultClusterCallback callback, Integer value) {
+      writeNullableBitmap8Attribute(callback, value, 0);
+    }
 
-    private native void readInt8sAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void writeNullableBitmap8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_BITMAP8_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableBitmap8Attribute(
+        NullableBitmap8AttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_BITMAP8_ATTRIBUTE_ID);
 
-    private native void subscribeInt8sAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_BITMAP8_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readInt16sAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void readNullableBitmap16Attribute(
+        NullableBitmap16AttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_BITMAP16_ATTRIBUTE_ID);
 
-    private native void writeInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_BITMAP16_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeInt16sAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableBitmap16Attribute(DefaultClusterCallback callback, Integer value) {
+      writeNullableBitmap16Attribute(callback, value, 0);
+    }
 
-    private native void readInt24sAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void writeNullableBitmap16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_BITMAP16_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeInt24sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableBitmap16Attribute(
+        NullableBitmap16AttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_BITMAP16_ATTRIBUTE_ID);
 
-    private native void subscribeInt24sAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_BITMAP16_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readInt32sAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void readNullableBitmap32Attribute(
+        NullableBitmap32AttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_BITMAP32_ATTRIBUTE_ID);
 
-    private native void writeInt32sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_BITMAP32_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeInt32sAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableBitmap32Attribute(DefaultClusterCallback callback, Long value) {
+      writeNullableBitmap32Attribute(callback, value, 0);
+    }
 
-    private native void readInt40sAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void writeNullableBitmap32Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_BITMAP32_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeInt40sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableBitmap32Attribute(
+        NullableBitmap32AttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_BITMAP32_ATTRIBUTE_ID);
 
-    private native void subscribeInt40sAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_BITMAP32_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readInt48sAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void readNullableBitmap64Attribute(
+        NullableBitmap64AttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_BITMAP64_ATTRIBUTE_ID);
 
-    private native void writeInt48sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_BITMAP64_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeInt48sAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableBitmap64Attribute(DefaultClusterCallback callback, Long value) {
+      writeNullableBitmap64Attribute(callback, value, 0);
+    }
 
-    private native void readInt56sAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void writeNullableBitmap64Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_BITMAP64_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeInt56sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableBitmap64Attribute(
+        NullableBitmap64AttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_BITMAP64_ATTRIBUTE_ID);
 
-    private native void subscribeInt56sAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_BITMAP64_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readInt64sAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void readNullableInt8uAttribute(
+        NullableInt8uAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT8U_ATTRIBUTE_ID);
 
-    private native void writeInt64sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_INT8U_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeInt64sAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableInt8uAttribute(DefaultClusterCallback callback, Integer value) {
+      writeNullableInt8uAttribute(callback, value, 0);
+    }
 
-    private native void readEnum8Attribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void writeNullableInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_INT8U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeEnum8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableInt8uAttribute(
+        NullableInt8uAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT8U_ATTRIBUTE_ID);
 
-    private native void subscribeEnum8Attribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_INT8U_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readEnum16Attribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void readNullableInt16uAttribute(
+        NullableInt16uAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT16U_ATTRIBUTE_ID);
 
-    private native void writeEnum16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_INT16U_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeEnum16Attribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableInt16uAttribute(DefaultClusterCallback callback, Integer value) {
+      writeNullableInt16uAttribute(callback, value, 0);
+    }
 
-    private native void readFloatSingleAttribute(long chipClusterPtr, FloatAttributeCallback callback);
+    public void writeNullableInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_INT16U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeFloatSingleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Float value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableInt16uAttribute(
+        NullableInt16uAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT16U_ATTRIBUTE_ID);
 
-    private native void subscribeFloatSingleAttribute(long chipClusterPtr, FloatAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_INT16U_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readFloatDoubleAttribute(long chipClusterPtr, DoubleAttributeCallback callback);
+    public void readNullableInt24uAttribute(
+        NullableInt24uAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT24U_ATTRIBUTE_ID);
 
-    private native void writeFloatDoubleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Double value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_INT24U_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeFloatDoubleAttribute(long chipClusterPtr, DoubleAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableInt24uAttribute(DefaultClusterCallback callback, Long value) {
+      writeNullableInt24uAttribute(callback, value, 0);
+    }
 
-    private native void readOctetStringAttribute(long chipClusterPtr, OctetStringAttributeCallback callback);
+    public void writeNullableInt24uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_INT24U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, byte[] value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableInt24uAttribute(
+        NullableInt24uAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT24U_ATTRIBUTE_ID);
 
-    private native void subscribeOctetStringAttribute(long chipClusterPtr, OctetStringAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_INT24U_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readListInt8uAttribute(long chipClusterPtr, ListInt8uAttributeCallback callback);
+    public void readNullableInt32uAttribute(
+        NullableInt32uAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT32U_ATTRIBUTE_ID);
 
-    private native void writeListInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList<Integer> value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_INT32U_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeListInt8uAttribute(long chipClusterPtr, ListInt8uAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableInt32uAttribute(DefaultClusterCallback callback, Long value) {
+      writeNullableInt32uAttribute(callback, value, 0);
+    }
 
-    private native void readListOctetStringAttribute(long chipClusterPtr, ListOctetStringAttributeCallback callback);
+    public void writeNullableInt32uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_INT32U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeListOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList<byte[]> value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableInt32uAttribute(
+        NullableInt32uAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT32U_ATTRIBUTE_ID);
 
-    private native void subscribeListOctetStringAttribute(long chipClusterPtr, ListOctetStringAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_INT32U_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readListStructOctetStringAttribute(long chipClusterPtr, ListStructOctetStringAttributeCallback callback);
+    public void readNullableInt40uAttribute(
+        NullableInt40uAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT40U_ATTRIBUTE_ID);
 
-    private native void writeListStructOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList<ChipStructs.UnitTestingClusterTestListStructOctet> value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_INT40U_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeListStructOctetStringAttribute(long chipClusterPtr, ListStructOctetStringAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableInt40uAttribute(DefaultClusterCallback callback, Long value) {
+      writeNullableInt40uAttribute(callback, value, 0);
+    }
 
-    private native void readLongOctetStringAttribute(long chipClusterPtr, OctetStringAttributeCallback callback);
+    public void writeNullableInt40uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_INT40U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeLongOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, byte[] value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableInt40uAttribute(
+        NullableInt40uAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT40U_ATTRIBUTE_ID);
 
-    private native void subscribeLongOctetStringAttribute(long chipClusterPtr, OctetStringAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_INT40U_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readCharStringAttribute(long chipClusterPtr, CharStringAttributeCallback callback);
+    public void readNullableInt48uAttribute(
+        NullableInt48uAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT48U_ATTRIBUTE_ID);
 
-    private native void writeCharStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_INT48U_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeCharStringAttribute(long chipClusterPtr, CharStringAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableInt48uAttribute(DefaultClusterCallback callback, Long value) {
+      writeNullableInt48uAttribute(callback, value, 0);
+    }
 
-    private native void readLongCharStringAttribute(long chipClusterPtr, CharStringAttributeCallback callback);
+    public void writeNullableInt48uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_INT48U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeLongCharStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableInt48uAttribute(
+        NullableInt48uAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT48U_ATTRIBUTE_ID);
 
-    private native void subscribeLongCharStringAttribute(long chipClusterPtr, CharStringAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_INT48U_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readEpochUsAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void readNullableInt56uAttribute(
+        NullableInt56uAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT56U_ATTRIBUTE_ID);
 
-    private native void writeEpochUsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_INT56U_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeEpochUsAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableInt56uAttribute(DefaultClusterCallback callback, Long value) {
+      writeNullableInt56uAttribute(callback, value, 0);
+    }
 
-    private native void readEpochSAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void writeNullableInt56uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_INT56U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeEpochSAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableInt56uAttribute(
+        NullableInt56uAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT56U_ATTRIBUTE_ID);
 
-    private native void subscribeEpochSAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_INT56U_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readVendorIdAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void readNullableInt64uAttribute(
+        NullableInt64uAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT64U_ATTRIBUTE_ID);
 
-    private native void writeVendorIdAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_INT64U_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeVendorIdAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableInt64uAttribute(DefaultClusterCallback callback, Long value) {
+      writeNullableInt64uAttribute(callback, value, 0);
+    }
 
-    private native void readListNullablesAndOptionalsStructAttribute(long chipClusterPtr, ListNullablesAndOptionalsStructAttributeCallback callback);
+    public void writeNullableInt64uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_INT64U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeListNullablesAndOptionalsStructAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList<ChipStructs.UnitTestingClusterNullablesAndOptionalsStruct> value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableInt64uAttribute(
+        NullableInt64uAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT64U_ATTRIBUTE_ID);
 
-    private native void subscribeListNullablesAndOptionalsStructAttribute(long chipClusterPtr, ListNullablesAndOptionalsStructAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_INT64U_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readEnumAttrAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void readNullableInt8sAttribute(
+        NullableInt8sAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT8S_ATTRIBUTE_ID);
 
-    private native void writeEnumAttrAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_INT8S_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeEnumAttrAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableInt8sAttribute(DefaultClusterCallback callback, Integer value) {
+      writeNullableInt8sAttribute(callback, value, 0);
+    }
 
-    private native void readStructAttrAttribute(long chipClusterPtr, StructAttrAttributeCallback callback);
+    public void writeNullableInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new IntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_INT8S_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeStructAttrAttribute(long chipClusterPtr, DefaultClusterCallback callback, ChipStructs.UnitTestingClusterSimpleStruct value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableInt8sAttribute(
+        NullableInt8sAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT8S_ATTRIBUTE_ID);
 
-    private native void subscribeStructAttrAttribute(long chipClusterPtr, StructAttrAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_INT8S_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readRangeRestrictedInt8uAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void readNullableInt16sAttribute(
+        NullableInt16sAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT16S_ATTRIBUTE_ID);
 
-    private native void writeRangeRestrictedInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_INT16S_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeRangeRestrictedInt8uAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableInt16sAttribute(DefaultClusterCallback callback, Integer value) {
+      writeNullableInt16sAttribute(callback, value, 0);
+    }
 
-    private native void readRangeRestrictedInt8sAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void writeNullableInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new IntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_INT16S_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeRangeRestrictedInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableInt16sAttribute(
+        NullableInt16sAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT16S_ATTRIBUTE_ID);
 
-    private native void subscribeRangeRestrictedInt8sAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_INT16S_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readRangeRestrictedInt16uAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void readNullableInt24sAttribute(
+        NullableInt24sAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT24S_ATTRIBUTE_ID);
 
-    private native void writeRangeRestrictedInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_INT24S_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeRangeRestrictedInt16uAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableInt24sAttribute(DefaultClusterCallback callback, Long value) {
+      writeNullableInt24sAttribute(callback, value, 0);
+    }
 
-    private native void readRangeRestrictedInt16sAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void writeNullableInt24sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new IntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_INT24S_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeRangeRestrictedInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableInt24sAttribute(
+        NullableInt24sAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT24S_ATTRIBUTE_ID);
 
-    private native void subscribeRangeRestrictedInt16sAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_INT24S_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readListLongOctetStringAttribute(long chipClusterPtr, ListLongOctetStringAttributeCallback callback);
+    public void readNullableInt32sAttribute(
+        NullableInt32sAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT32S_ATTRIBUTE_ID);
 
-    private native void writeListLongOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList<byte[]> value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_INT32S_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeListLongOctetStringAttribute(long chipClusterPtr, ListLongOctetStringAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableInt32sAttribute(DefaultClusterCallback callback, Long value) {
+      writeNullableInt32sAttribute(callback, value, 0);
+    }
 
-    private native void readListFabricScopedAttribute(long chipClusterPtr, ListFabricScopedAttributeCallback callback, boolean isFabricFiltered);
+    public void writeNullableInt32sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new IntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_INT32S_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeListFabricScopedAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList<ChipStructs.UnitTestingClusterTestFabricScoped> value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableInt32sAttribute(
+        NullableInt32sAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT32S_ATTRIBUTE_ID);
 
-    private native void subscribeListFabricScopedAttribute(long chipClusterPtr, ListFabricScopedAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_INT32S_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readTimedWriteBooleanAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
+    public void readNullableInt40sAttribute(
+        NullableInt40sAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT40S_ATTRIBUTE_ID);
 
-    private native void writeTimedWriteBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_INT40S_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeTimedWriteBooleanAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableInt40sAttribute(DefaultClusterCallback callback, Long value) {
+      writeNullableInt40sAttribute(callback, value, 0);
+    }
 
-    private native void readGeneralErrorBooleanAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
+    public void writeNullableInt40sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new IntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_INT40S_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeGeneralErrorBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableInt40sAttribute(
+        NullableInt40sAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT40S_ATTRIBUTE_ID);
 
-    private native void subscribeGeneralErrorBooleanAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_INT40S_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readClusterErrorBooleanAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
+    public void readNullableInt48sAttribute(
+        NullableInt48sAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT48S_ATTRIBUTE_ID);
 
-    private native void writeClusterErrorBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_INT48S_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeClusterErrorBooleanAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableInt48sAttribute(DefaultClusterCallback callback, Long value) {
+      writeNullableInt48sAttribute(callback, value, 0);
+    }
 
-    private native void readUnsupportedAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
+    public void writeNullableInt48sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new IntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_INT48S_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeUnsupportedAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableInt48sAttribute(
+        NullableInt48sAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT48S_ATTRIBUTE_ID);
 
-    private native void subscribeUnsupportedAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_INT48S_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readNullableBooleanAttribute(long chipClusterPtr, NullableBooleanAttributeCallback callback);
+    public void readNullableInt56sAttribute(
+        NullableInt56sAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT56S_ATTRIBUTE_ID);
 
-    private native void writeNullableBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_INT56S_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeNullableBooleanAttribute(long chipClusterPtr, NullableBooleanAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableInt56sAttribute(DefaultClusterCallback callback, Long value) {
+      writeNullableInt56sAttribute(callback, value, 0);
+    }
 
-    private native void readNullableBitmap8Attribute(long chipClusterPtr, NullableBitmap8AttributeCallback callback);
+    public void writeNullableInt56sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new IntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_INT56S_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeNullableBitmap8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableInt56sAttribute(
+        NullableInt56sAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT56S_ATTRIBUTE_ID);
 
-    private native void subscribeNullableBitmap8Attribute(long chipClusterPtr, NullableBitmap8AttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_INT56S_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readNullableBitmap16Attribute(long chipClusterPtr, NullableBitmap16AttributeCallback callback);
+    public void readNullableInt64sAttribute(
+        NullableInt64sAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT64S_ATTRIBUTE_ID);
 
-    private native void writeNullableBitmap16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_INT64S_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeNullableBitmap16Attribute(long chipClusterPtr, NullableBitmap16AttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableInt64sAttribute(DefaultClusterCallback callback, Long value) {
+      writeNullableInt64sAttribute(callback, value, 0);
+    }
 
-    private native void readNullableBitmap32Attribute(long chipClusterPtr, NullableBitmap32AttributeCallback callback);
+    public void writeNullableInt64sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new IntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_INT64S_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeNullableBitmap32Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableInt64sAttribute(
+        NullableInt64sAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_INT64S_ATTRIBUTE_ID);
 
-    private native void subscribeNullableBitmap32Attribute(long chipClusterPtr, NullableBitmap32AttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_INT64S_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readNullableBitmap64Attribute(long chipClusterPtr, NullableBitmap64AttributeCallback callback);
+    public void readNullableEnum8Attribute(
+        NullableEnum8AttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_ENUM8_ATTRIBUTE_ID);
 
-    private native void writeNullableBitmap64Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_ENUM8_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeNullableBitmap64Attribute(long chipClusterPtr, NullableBitmap64AttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableEnum8Attribute(DefaultClusterCallback callback, Integer value) {
+      writeNullableEnum8Attribute(callback, value, 0);
+    }
 
-    private native void readNullableInt8uAttribute(long chipClusterPtr, NullableInt8uAttributeCallback callback);
+    public void writeNullableEnum8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_ENUM8_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeNullableInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableEnum8Attribute(
+        NullableEnum8AttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_ENUM8_ATTRIBUTE_ID);
 
-    private native void subscribeNullableInt8uAttribute(long chipClusterPtr, NullableInt8uAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_ENUM8_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readNullableInt16uAttribute(long chipClusterPtr, NullableInt16uAttributeCallback callback);
+    public void readNullableEnum16Attribute(
+        NullableEnum16AttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_ENUM16_ATTRIBUTE_ID);
 
-    private native void writeNullableInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_ENUM16_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeNullableInt16uAttribute(long chipClusterPtr, NullableInt16uAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableEnum16Attribute(DefaultClusterCallback callback, Integer value) {
+      writeNullableEnum16Attribute(callback, value, 0);
+    }
 
-    private native void readNullableInt24uAttribute(long chipClusterPtr, NullableInt24uAttributeCallback callback);
+    public void writeNullableEnum16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_ENUM16_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeNullableInt24uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableEnum16Attribute(
+        NullableEnum16AttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_ENUM16_ATTRIBUTE_ID);
 
-    private native void subscribeNullableInt24uAttribute(long chipClusterPtr, NullableInt24uAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_ENUM16_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readNullableInt32uAttribute(long chipClusterPtr, NullableInt32uAttributeCallback callback);
+    public void readNullableFloatSingleAttribute(
+        NullableFloatSingleAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_FLOAT_SINGLE_ATTRIBUTE_ID);
 
-    private native void writeNullableInt32uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_FLOAT_SINGLE_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeNullableInt32uAttribute(long chipClusterPtr, NullableInt32uAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableFloatSingleAttribute(DefaultClusterCallback callback, Float value) {
+      writeNullableFloatSingleAttribute(callback, value, 0);
+    }
 
-    private native void readNullableInt40uAttribute(long chipClusterPtr, NullableInt40uAttributeCallback callback);
+    public void writeNullableFloatSingleAttribute(DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new FloatType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_FLOAT_SINGLE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeNullableInt40uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableFloatSingleAttribute(
+        NullableFloatSingleAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_FLOAT_SINGLE_ATTRIBUTE_ID);
 
-    private native void subscribeNullableInt40uAttribute(long chipClusterPtr, NullableInt40uAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Float value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_FLOAT_SINGLE_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readNullableInt48uAttribute(long chipClusterPtr, NullableInt48uAttributeCallback callback);
+    public void readNullableFloatDoubleAttribute(
+        NullableFloatDoubleAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_FLOAT_DOUBLE_ATTRIBUTE_ID);
 
-    private native void writeNullableInt48uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Double value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_FLOAT_DOUBLE_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeNullableInt48uAttribute(long chipClusterPtr, NullableInt48uAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableFloatDoubleAttribute(DefaultClusterCallback callback, Double value) {
+      writeNullableFloatDoubleAttribute(callback, value, 0);
+    }
 
-    private native void readNullableInt56uAttribute(long chipClusterPtr, NullableInt56uAttributeCallback callback);
+    public void writeNullableFloatDoubleAttribute(DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new DoubleType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_FLOAT_DOUBLE_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeNullableInt56uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableFloatDoubleAttribute(
+        NullableFloatDoubleAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_FLOAT_DOUBLE_ATTRIBUTE_ID);
 
-    private native void subscribeNullableInt56uAttribute(long chipClusterPtr, NullableInt56uAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Double value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_FLOAT_DOUBLE_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readNullableInt64uAttribute(long chipClusterPtr, NullableInt64uAttributeCallback callback);
+    public void readNullableOctetStringAttribute(
+        NullableOctetStringAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_OCTET_STRING_ATTRIBUTE_ID);
 
-    private native void writeNullableInt64uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable byte[] value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_OCTET_STRING_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeNullableInt64uAttribute(long chipClusterPtr, NullableInt64uAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableOctetStringAttribute(DefaultClusterCallback callback, byte[] value) {
+      writeNullableOctetStringAttribute(callback, value, 0);
+    }
 
-    private native void readNullableInt8sAttribute(long chipClusterPtr, NullableInt8sAttributeCallback callback);
+    public void writeNullableOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new ByteArrayType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_OCTET_STRING_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeNullableInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableOctetStringAttribute(
+        NullableOctetStringAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_OCTET_STRING_ATTRIBUTE_ID);
 
-    private native void subscribeNullableInt8sAttribute(long chipClusterPtr, NullableInt8sAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable byte[] value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_OCTET_STRING_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readNullableInt16sAttribute(long chipClusterPtr, NullableInt16sAttributeCallback callback);
+    public void readNullableCharStringAttribute(
+        NullableCharStringAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_CHAR_STRING_ATTRIBUTE_ID);
 
-    private native void writeNullableInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_CHAR_STRING_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeNullableInt16sAttribute(long chipClusterPtr, NullableInt16sAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableCharStringAttribute(DefaultClusterCallback callback, String value) {
+      writeNullableCharStringAttribute(callback, value, 0);
+    }
 
-    private native void readNullableInt24sAttribute(long chipClusterPtr, NullableInt24sAttributeCallback callback);
+    public void writeNullableCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new StringType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_CHAR_STRING_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeNullableInt24sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableCharStringAttribute(
+        NullableCharStringAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_CHAR_STRING_ATTRIBUTE_ID);
 
-    private native void subscribeNullableInt24sAttribute(long chipClusterPtr, NullableInt24sAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_CHAR_STRING_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readNullableInt32sAttribute(long chipClusterPtr, NullableInt32sAttributeCallback callback);
+    public void readNullableEnumAttrAttribute(
+        NullableEnumAttrAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_ENUM_ATTR_ATTRIBUTE_ID);
 
-    private native void writeNullableInt32sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_ENUM_ATTR_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeNullableInt32sAttribute(long chipClusterPtr, NullableInt32sAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableEnumAttrAttribute(DefaultClusterCallback callback, Integer value) {
+      writeNullableEnumAttrAttribute(callback, value, 0);
+    }
 
-    private native void readNullableInt40sAttribute(long chipClusterPtr, NullableInt40sAttributeCallback callback);
+    public void writeNullableEnumAttrAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_ENUM_ATTR_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeNullableInt40sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableEnumAttrAttribute(
+        NullableEnumAttrAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_ENUM_ATTR_ATTRIBUTE_ID);
 
-    private native void subscribeNullableInt40sAttribute(long chipClusterPtr, NullableInt40sAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_ENUM_ATTR_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readNullableInt48sAttribute(long chipClusterPtr, NullableInt48sAttributeCallback callback);
+    public void readNullableStructAttribute(
+        NullableStructAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_STRUCT_ATTRIBUTE_ID);
 
-    private native void writeNullableInt48sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable ChipStructs.UnitTestingClusterSimpleStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_STRUCT_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeNullableInt48sAttribute(long chipClusterPtr, NullableInt48sAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableStructAttribute(DefaultClusterCallback callback, ChipStructs.UnitTestingClusterSimpleStruct value) {
+      writeNullableStructAttribute(callback, value, 0);
+    }
 
-    private native void readNullableInt56sAttribute(long chipClusterPtr, NullableInt56sAttributeCallback callback);
+    public void writeNullableStructAttribute(DefaultClusterCallback callback, ChipStructs.UnitTestingClusterSimpleStruct value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? value.encodeTlv() : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_STRUCT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeNullableInt56sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableStructAttribute(
+        NullableStructAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_STRUCT_ATTRIBUTE_ID);
 
-    private native void subscribeNullableInt56sAttribute(long chipClusterPtr, NullableInt56sAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable ChipStructs.UnitTestingClusterSimpleStruct value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_STRUCT_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readNullableInt64sAttribute(long chipClusterPtr, NullableInt64sAttributeCallback callback);
+    public void readNullableRangeRestrictedInt8uAttribute(
+        NullableRangeRestrictedInt8uAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_RANGE_RESTRICTED_INT8U_ATTRIBUTE_ID);
 
-    private native void writeNullableInt64sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_RANGE_RESTRICTED_INT8U_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeNullableInt64sAttribute(long chipClusterPtr, NullableInt64sAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value) {
+      writeNullableRangeRestrictedInt8uAttribute(callback, value, 0);
+    }
 
-    private native void readNullableEnum8Attribute(long chipClusterPtr, NullableEnum8AttributeCallback callback);
+    public void writeNullableRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_RANGE_RESTRICTED_INT8U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeNullableEnum8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableRangeRestrictedInt8uAttribute(
+        NullableRangeRestrictedInt8uAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_RANGE_RESTRICTED_INT8U_ATTRIBUTE_ID);
 
-    private native void subscribeNullableEnum8Attribute(long chipClusterPtr, NullableEnum8AttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_RANGE_RESTRICTED_INT8U_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readNullableEnum16Attribute(long chipClusterPtr, NullableEnum16AttributeCallback callback);
+    public void readNullableRangeRestrictedInt8sAttribute(
+        NullableRangeRestrictedInt8sAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_RANGE_RESTRICTED_INT8S_ATTRIBUTE_ID);
 
-    private native void writeNullableEnum16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_RANGE_RESTRICTED_INT8S_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeNullableEnum16Attribute(long chipClusterPtr, NullableEnum16AttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value) {
+      writeNullableRangeRestrictedInt8sAttribute(callback, value, 0);
+    }
 
-    private native void readNullableFloatSingleAttribute(long chipClusterPtr, NullableFloatSingleAttributeCallback callback);
+    public void writeNullableRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new IntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_RANGE_RESTRICTED_INT8S_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeNullableFloatSingleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Float value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableRangeRestrictedInt8sAttribute(
+        NullableRangeRestrictedInt8sAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_RANGE_RESTRICTED_INT8S_ATTRIBUTE_ID);
 
-    private native void subscribeNullableFloatSingleAttribute(long chipClusterPtr, NullableFloatSingleAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_RANGE_RESTRICTED_INT8S_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readNullableFloatDoubleAttribute(long chipClusterPtr, NullableFloatDoubleAttributeCallback callback);
+    public void readNullableRangeRestrictedInt16uAttribute(
+        NullableRangeRestrictedInt16uAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_RANGE_RESTRICTED_INT16U_ATTRIBUTE_ID);
 
-    private native void writeNullableFloatDoubleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Double value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_RANGE_RESTRICTED_INT16U_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeNullableFloatDoubleAttribute(long chipClusterPtr, NullableFloatDoubleAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value) {
+      writeNullableRangeRestrictedInt16uAttribute(callback, value, 0);
+    }
 
-    private native void readNullableOctetStringAttribute(long chipClusterPtr, NullableOctetStringAttributeCallback callback);
+    public void writeNullableRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_RANGE_RESTRICTED_INT16U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeNullableOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, byte[] value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableRangeRestrictedInt16uAttribute(
+        NullableRangeRestrictedInt16uAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_RANGE_RESTRICTED_INT16U_ATTRIBUTE_ID);
 
-    private native void subscribeNullableOctetStringAttribute(long chipClusterPtr, NullableOctetStringAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_RANGE_RESTRICTED_INT16U_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readNullableCharStringAttribute(long chipClusterPtr, NullableCharStringAttributeCallback callback);
+    public void readNullableRangeRestrictedInt16sAttribute(
+        NullableRangeRestrictedInt16sAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_RANGE_RESTRICTED_INT16S_ATTRIBUTE_ID);
 
-    private native void writeNullableCharStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, NULLABLE_RANGE_RESTRICTED_INT16S_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeNullableCharStringAttribute(long chipClusterPtr, NullableCharStringAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeNullableRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value) {
+      writeNullableRangeRestrictedInt16sAttribute(callback, value, 0);
+    }
 
-    private native void readNullableEnumAttrAttribute(long chipClusterPtr, NullableEnumAttrAttributeCallback callback);
+    public void writeNullableRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = value != null ? new IntType(value) : new NullType();
+      writeAttribute(new WriteAttributesCallbackImpl(callback), NULLABLE_RANGE_RESTRICTED_INT16S_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeNullableEnumAttrAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeNullableRangeRestrictedInt16sAttribute(
+        NullableRangeRestrictedInt16sAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NULLABLE_RANGE_RESTRICTED_INT16S_ATTRIBUTE_ID);
 
-    private native void subscribeNullableEnumAttrAttribute(long chipClusterPtr, NullableEnumAttrAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, NULLABLE_RANGE_RESTRICTED_INT16S_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readNullableStructAttribute(long chipClusterPtr, NullableStructAttributeCallback callback);
+    public void readWriteOnlyInt8uAttribute(
+        IntegerAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WRITE_ONLY_INT8U_ATTRIBUTE_ID);
 
-    private native void writeNullableStructAttribute(long chipClusterPtr, DefaultClusterCallback callback, ChipStructs.UnitTestingClusterSimpleStruct value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, WRITE_ONLY_INT8U_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeNullableStructAttribute(long chipClusterPtr, NullableStructAttributeCallback callback, int minInterval, int maxInterval);
+    public void writeWriteOnlyInt8uAttribute(DefaultClusterCallback callback, Integer value) {
+      writeWriteOnlyInt8uAttribute(callback, value, 0);
+    }
 
-    private native void readNullableRangeRestrictedInt8uAttribute(long chipClusterPtr, NullableRangeRestrictedInt8uAttributeCallback callback);
+    public void writeWriteOnlyInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+      BaseTLVType tlvValue = new UIntType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), WRITE_ONLY_INT8U_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+    }
 
-    private native void writeNullableRangeRestrictedInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeWriteOnlyInt8uAttribute(
+        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, WRITE_ONLY_INT8U_ATTRIBUTE_ID);
 
-    private native void subscribeNullableRangeRestrictedInt8uAttribute(long chipClusterPtr, NullableRangeRestrictedInt8uAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, WRITE_ONLY_INT8U_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readNullableRangeRestrictedInt8sAttribute(long chipClusterPtr, NullableRangeRestrictedInt8sAttributeCallback callback);
+    public void readGeneratedCommandListAttribute(
+        GeneratedCommandListAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
 
-    private native void writeNullableRangeRestrictedInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
+    }
 
-    private native void subscribeNullableRangeRestrictedInt8sAttribute(long chipClusterPtr, NullableRangeRestrictedInt8sAttributeCallback callback, int minInterval, int maxInterval);
+    public void subscribeGeneratedCommandListAttribute(
+        GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
 
-    private native void readNullableRangeRestrictedInt16uAttribute(long chipClusterPtr, NullableRangeRestrictedInt16uAttributeCallback callback);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void writeNullableRangeRestrictedInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    public void readAcceptedCommandListAttribute(
+        AcceptedCommandListAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
 
-    private native void subscribeNullableRangeRestrictedInt16uAttribute(long chipClusterPtr, NullableRangeRestrictedInt16uAttributeCallback callback, int minInterval, int maxInterval);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
+    }
 
-    private native void readNullableRangeRestrictedInt16sAttribute(long chipClusterPtr, NullableRangeRestrictedInt16sAttributeCallback callback);
+    public void subscribeAcceptedCommandListAttribute(
+        AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
 
-    private native void writeNullableRangeRestrictedInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void subscribeNullableRangeRestrictedInt16sAttribute(long chipClusterPtr, NullableRangeRestrictedInt16sAttributeCallback callback, int minInterval, int maxInterval);
+    public void readEventListAttribute(
+        EventListAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
 
-    private native void readWriteOnlyInt8uAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
+    }
 
-    private native void writeWriteOnlyInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs);
+    public void subscribeEventListAttribute(
+        EventListAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
 
-    private native void subscribeWriteOnlyInt8uAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
+    public void readAttributeListAttribute(
+        AttributeListAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
 
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
+    }
 
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
+    public void subscribeAttributeListAttribute(
+        AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
 
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
+    public void readFeatureMapAttribute(
+        LongAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
 
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
+    }
 
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
+    public void subscribeFeatureMapAttribute(
+        LongAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
 
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
 
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
+    public void readClusterRevisionAttribute(
+        IntegerAttributeCallback callback) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
+    }
 
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
+    public void subscribeClusterRevisionAttribute(
+        IntegerAttributeCallback callback, int minInterval, int maxInterval) {
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class FaultInjectionCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 4294048774L;
 
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public FaultInjectionCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void failAtFault(DefaultClusterCallback callback, Integer type, Long id, Long numCallsToSkip, Long numCallsToFail, Boolean takeMutex) {
-      failAtFault(chipClusterPtr, callback, type, id, numCallsToSkip, numCallsToFail, takeMutex, null);
+      failAtFault(callback, type, id, numCallsToSkip, numCallsToFail, takeMutex, 0);
     }
 
     public void failAtFault(DefaultClusterCallback callback, Integer type, Long id, Long numCallsToSkip, Long numCallsToFail, Boolean takeMutex, int timedInvokeTimeoutMs) {
-      failAtFault(chipClusterPtr, callback, type, id, numCallsToSkip, numCallsToFail, takeMutex, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long typeFieldID = 0L;
+      BaseTLVType typetlvValue = new UIntType(type);
+      elements.add(new StructElement(typeFieldID, typetlvValue));
+
+      final long idFieldID = 1L;
+      BaseTLVType idtlvValue = new UIntType(id);
+      elements.add(new StructElement(idFieldID, idtlvValue));
+
+      final long numCallsToSkipFieldID = 2L;
+      BaseTLVType numCallsToSkiptlvValue = new UIntType(numCallsToSkip);
+      elements.add(new StructElement(numCallsToSkipFieldID, numCallsToSkiptlvValue));
+
+      final long numCallsToFailFieldID = 3L;
+      BaseTLVType numCallsToFailtlvValue = new UIntType(numCallsToFail);
+      elements.add(new StructElement(numCallsToFailFieldID, numCallsToFailtlvValue));
+
+      final long takeMutexFieldID = 4L;
+      BaseTLVType takeMutextlvValue = new BooleanType(takeMutex);
+      elements.add(new StructElement(takeMutexFieldID, takeMutextlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void failRandomlyAtFault(DefaultClusterCallback callback, Integer type, Long id, Integer percentage) {
-      failRandomlyAtFault(chipClusterPtr, callback, type, id, percentage, null);
+      failRandomlyAtFault(callback, type, id, percentage, 0);
     }
 
     public void failRandomlyAtFault(DefaultClusterCallback callback, Integer type, Long id, Integer percentage, int timedInvokeTimeoutMs) {
-      failRandomlyAtFault(chipClusterPtr, callback, type, id, percentage, timedInvokeTimeoutMs);
-    }
+      final long commandId = 1L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long typeFieldID = 0L;
+      BaseTLVType typetlvValue = new UIntType(type);
+      elements.add(new StructElement(typeFieldID, typetlvValue));
 
-    private native void failAtFault(long chipClusterPtr, DefaultClusterCallback callback, Integer type, Long id, Long numCallsToSkip, Long numCallsToFail, Boolean takeMutex, @Nullable Integer timedInvokeTimeoutMs);
+      final long idFieldID = 1L;
+      BaseTLVType idtlvValue = new UIntType(id);
+      elements.add(new StructElement(idFieldID, idtlvValue));
 
-    private native void failRandomlyAtFault(long chipClusterPtr, DefaultClusterCallback callback, Integer type, Long id, Integer percentage, @Nullable Integer timedInvokeTimeoutMs);
+      final long percentageFieldID = 2L;
+      BaseTLVType percentagetlvValue = new UIntType(percentage);
+      elements.add(new StructElement(percentageFieldID, percentagetlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 
   public static class SampleMeiCluster extends BaseChipCluster {
     public static final long CLUSTER_ID = 4294048800L;
 
+    private static final long FLIP_FLOP_ATTRIBUTE_ID = 0L;
+    private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+    private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+    private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+    private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+    private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+    private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
     public SampleMeiCluster(long devicePtr, int endpointId) {
-      super(devicePtr, endpointId);
+      super(devicePtr, endpointId, CLUSTER_ID);
     }
 
     @Override
-    public native long initWithDevice(long devicePtr, int endpointId);
+    @Deprecated
+    public long initWithDevice(long devicePtr, int endpointId) {
+      return 0L;
+    }
 
     public void ping(DefaultClusterCallback callback) {
-      ping(chipClusterPtr, callback, null);
+      ping(callback, 0);
     }
 
     public void ping(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
-      ping(chipClusterPtr, callback, timedInvokeTimeoutMs);
+      final long commandId = 0L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          callback.onSuccess();
+        }}, commandId, value, timedInvokeTimeoutMs);
     }
 
     public void addArguments(AddArgumentsResponseCallback callback, Integer arg1, Integer arg2) {
-      addArguments(chipClusterPtr, callback, arg1, arg2, null);
+      addArguments(callback, arg1, arg2, 0);
     }
 
     public void addArguments(AddArgumentsResponseCallback callback, Integer arg1, Integer arg2, int timedInvokeTimeoutMs) {
-      addArguments(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs);
-    }
-
-    private native void ping(long chipClusterPtr, DefaultClusterCallback callback, @Nullable Integer timedInvokeTimeoutMs);
-
-    private native void addArguments(long chipClusterPtr, AddArgumentsResponseCallback callback, Integer arg1, Integer arg2, @Nullable Integer timedInvokeTimeoutMs);
-
-    public interface AddArgumentsResponseCallback {
+      final long commandId = 2L;
+
+      ArrayList<StructElement> elements = new ArrayList<>();
+      final long arg1FieldID = 0L;
+      BaseTLVType arg1tlvValue = new UIntType(arg1);
+      elements.add(new StructElement(arg1FieldID, arg1tlvValue));
+
+      final long arg2FieldID = 1L;
+      BaseTLVType arg2tlvValue = new UIntType(arg2);
+      elements.add(new StructElement(arg2FieldID, arg2tlvValue));
+
+      StructType value = new StructType(elements);
+      invoke(new InvokeCallbackImpl(callback) {
+          @Override
+          public void onResponse(StructType invokeStructValue) {
+          final long returnValueFieldID = 0L;
+          Integer returnValue = null;
+          for (StructElement element: invokeStructValue.value()) {
+            if (element.contextTagNum() == returnValueFieldID) {
+              if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+                UIntType castingValue = element.value(UIntType.class);
+                returnValue = castingValue.value(Integer.class);
+              }
+            }
+          }
+          callback.onSuccess(returnValue);
+        }}, commandId, value, timedInvokeTimeoutMs);
+    }
+
+    public interface AddArgumentsResponseCallback extends BaseClusterCallback {
       void onSuccess(Integer returnValue);
-      void onError(Exception error);
     }
 
-    public interface GeneratedCommandListAttributeCallback {
+    public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AcceptedCommandListAttributeCallback {
+    public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface EventListAttributeCallback {
+    public interface EventListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
-    public interface AttributeListAttributeCallback {
+    public interface AttributeListAttributeCallback extends BaseAttributeCallback {
       void onSuccess(List<Long> value);
-      void onError(Exception ex);
-      default void onSubscriptionEstablished(long subscriptionId) {}
     }
 
     public void readFlipFlopAttribute(
         BooleanAttributeCallback callback) {
-        readFlipFlopAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FLIP_FLOP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FLIP_FLOP_ATTRIBUTE_ID, true);
     }
 
     public void writeFlipFlopAttribute(DefaultClusterCallback callback, Boolean value) {
-        writeFlipFlopAttribute(chipClusterPtr, callback, value, null);
+      writeFlipFlopAttribute(callback, value, 0);
     }
 
     public void writeFlipFlopAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) {
-        writeFlipFlopAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs);
+      BaseTLVType tlvValue = new BooleanType(value);
+      writeAttribute(new WriteAttributesCallbackImpl(callback), FLIP_FLOP_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
     }
 
     public void subscribeFlipFlopAttribute(
         BooleanAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFlipFlopAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FLIP_FLOP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Boolean value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FLIP_FLOP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback) {
-        readGeneratedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeGeneratedCommandListAttribute(
         GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeGeneratedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback) {
-        readAcceptedCommandListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAcceptedCommandListAttribute(
         AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAcceptedCommandListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readEventListAttribute(
         EventListAttributeCallback callback) {
-        readEventListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeEventListAttribute(
         EventListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeEventListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readAttributeListAttribute(
         AttributeListAttributeCallback callback) {
-        readAttributeListAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
     }
 
     public void subscribeAttributeListAttribute(
         AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            List<Long> value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readFeatureMapAttribute(
         LongAttributeCallback callback) {
-        readFeatureMapAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, true);
     }
 
     public void subscribeFeatureMapAttribute(
         LongAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
     }
 
     public void readClusterRevisionAttribute(
         IntegerAttributeCallback callback) {
-        readClusterRevisionAttribute(chipClusterPtr, callback);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+      readAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+            callback.onSuccess(value);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
     }
 
     public void subscribeClusterRevisionAttribute(
         IntegerAttributeCallback callback, int minInterval, int maxInterval) {
-        subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval);
-    }
-
-    private native void readFlipFlopAttribute(long chipClusterPtr, BooleanAttributeCallback callback);
-
-    private native void writeFlipFlopAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs);
-
-    private native void subscribeFlipFlopAttribute(long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback);
-
-    private native void subscribeGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback);
-
-    private native void subscribeAcceptedCommandListAttribute(long chipClusterPtr, AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval);
+      ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
 
-    private native void readEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback);
-
-    private native void subscribeEventListAttribute(long chipClusterPtr, EventListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback);
-
-    private native void subscribeAttributeListAttribute(long chipClusterPtr, AttributeListAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback);
-
-    private native void subscribeFeatureMapAttribute(long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval);
-
-    private native void readClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback);
-
-    private native void subscribeClusterRevisionAttribute(long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval);
+      subscribeAttribute(new ReportCallbackImpl(callback, path) {
+          @Override
+          public void onSuccess(byte[] tlv) {
+            Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+          }
+        }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+    }
   }
 }
diff --git a/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java b/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java
index 5c4f9a7b529dc7..4534543f9d8634 100644
--- a/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java
+++ b/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java
@@ -21,6 +21,8 @@
 import java.util.Arrays;
 import java.util.Optional;
 
+import static chip.devicecontroller.ChipTLVType.*;
+
 public class ChipEventStructs {
 public static class AccessControlClusterAccessControlEntryChangedEvent {
   public @Nullable Long adminNodeID;
@@ -28,6 +30,12 @@ public static class AccessControlClusterAccessControlEntryChangedEvent {
   public Integer changeType;
   public @Nullable ChipStructs.AccessControlClusterAccessControlEntryStruct latestValue;
   public Integer fabricIndex;
+  private static final long ADMIN_NODE_I_D_ID = 1L;
+  private static final long ADMIN_PASSCODE_I_D_ID = 2L;
+  private static final long CHANGE_TYPE_ID = 3L;
+  private static final long LATEST_VALUE_ID = 4L;
+  private static final long FABRIC_INDEX_ID = 254L;
+
   public AccessControlClusterAccessControlEntryChangedEvent(
     @Nullable Long adminNodeID,
     @Nullable Integer adminPasscodeID,
@@ -42,6 +50,63 @@ public AccessControlClusterAccessControlEntryChangedEvent(
     this.fabricIndex = fabricIndex;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ADMIN_NODE_I_D_ID, adminNodeID != null ? new UIntType(adminNodeID) : new NullType()));
+    values.add(new StructElement(ADMIN_PASSCODE_I_D_ID, adminPasscodeID != null ? new UIntType(adminPasscodeID) : new NullType()));
+    values.add(new StructElement(CHANGE_TYPE_ID, new UIntType(changeType)));
+    values.add(new StructElement(LATEST_VALUE_ID, latestValue != null ? latestValue.encodeTlv() : new NullType()));
+    values.add(new StructElement(FABRIC_INDEX_ID, new UIntType(fabricIndex)));
+
+    return new StructType(values);
+  }
+
+  public static AccessControlClusterAccessControlEntryChangedEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    @Nullable Long adminNodeID = null;
+    @Nullable Integer adminPasscodeID = null;
+    Integer changeType = null;
+    @Nullable ChipStructs.AccessControlClusterAccessControlEntryStruct latestValue = null;
+    Integer fabricIndex = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ADMIN_NODE_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          adminNodeID = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == ADMIN_PASSCODE_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          adminPasscodeID = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == CHANGE_TYPE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          changeType = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == LATEST_VALUE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+          StructType castingValue = element.value(StructType.class);
+          latestValue = ChipStructs.AccessControlClusterAccessControlEntryStruct.decodeTlv(castingValue);
+        }
+      } else if (element.contextTagNum() == FABRIC_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricIndex = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new AccessControlClusterAccessControlEntryChangedEvent(
+      adminNodeID,
+      adminPasscodeID,
+      changeType,
+      latestValue,
+      fabricIndex
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -71,6 +136,12 @@ public static class AccessControlClusterAccessControlExtensionChangedEvent {
   public Integer changeType;
   public @Nullable ChipStructs.AccessControlClusterAccessControlExtensionStruct latestValue;
   public Integer fabricIndex;
+  private static final long ADMIN_NODE_I_D_ID = 1L;
+  private static final long ADMIN_PASSCODE_I_D_ID = 2L;
+  private static final long CHANGE_TYPE_ID = 3L;
+  private static final long LATEST_VALUE_ID = 4L;
+  private static final long FABRIC_INDEX_ID = 254L;
+
   public AccessControlClusterAccessControlExtensionChangedEvent(
     @Nullable Long adminNodeID,
     @Nullable Integer adminPasscodeID,
@@ -85,6 +156,63 @@ public AccessControlClusterAccessControlExtensionChangedEvent(
     this.fabricIndex = fabricIndex;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ADMIN_NODE_I_D_ID, adminNodeID != null ? new UIntType(adminNodeID) : new NullType()));
+    values.add(new StructElement(ADMIN_PASSCODE_I_D_ID, adminPasscodeID != null ? new UIntType(adminPasscodeID) : new NullType()));
+    values.add(new StructElement(CHANGE_TYPE_ID, new UIntType(changeType)));
+    values.add(new StructElement(LATEST_VALUE_ID, latestValue != null ? latestValue.encodeTlv() : new NullType()));
+    values.add(new StructElement(FABRIC_INDEX_ID, new UIntType(fabricIndex)));
+
+    return new StructType(values);
+  }
+
+  public static AccessControlClusterAccessControlExtensionChangedEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    @Nullable Long adminNodeID = null;
+    @Nullable Integer adminPasscodeID = null;
+    Integer changeType = null;
+    @Nullable ChipStructs.AccessControlClusterAccessControlExtensionStruct latestValue = null;
+    Integer fabricIndex = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ADMIN_NODE_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          adminNodeID = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == ADMIN_PASSCODE_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          adminPasscodeID = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == CHANGE_TYPE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          changeType = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == LATEST_VALUE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+          StructType castingValue = element.value(StructType.class);
+          latestValue = ChipStructs.AccessControlClusterAccessControlExtensionStruct.decodeTlv(castingValue);
+        }
+      } else if (element.contextTagNum() == FABRIC_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricIndex = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new AccessControlClusterAccessControlExtensionChangedEvent(
+      adminNodeID,
+      adminPasscodeID,
+      changeType,
+      latestValue,
+      fabricIndex
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -112,6 +240,10 @@ public static class ActionsClusterStateChangedEvent {
   public Integer actionID;
   public Long invokeID;
   public Integer newState;
+  private static final long ACTION_I_D_ID = 0L;
+  private static final long INVOKE_I_D_ID = 1L;
+  private static final long NEW_STATE_ID = 2L;
+
   public ActionsClusterStateChangedEvent(
     Integer actionID,
     Long invokeID,
@@ -122,6 +254,47 @@ public ActionsClusterStateChangedEvent(
     this.newState = newState;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ACTION_I_D_ID, new UIntType(actionID)));
+    values.add(new StructElement(INVOKE_I_D_ID, new UIntType(invokeID)));
+    values.add(new StructElement(NEW_STATE_ID, new UIntType(newState)));
+
+    return new StructType(values);
+  }
+
+  public static ActionsClusterStateChangedEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer actionID = null;
+    Long invokeID = null;
+    Integer newState = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ACTION_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          actionID = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == INVOKE_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          invokeID = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == NEW_STATE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          newState = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new ActionsClusterStateChangedEvent(
+      actionID,
+      invokeID,
+      newState
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -144,6 +317,11 @@ public static class ActionsClusterActionFailedEvent {
   public Long invokeID;
   public Integer newState;
   public Integer error;
+  private static final long ACTION_I_D_ID = 0L;
+  private static final long INVOKE_I_D_ID = 1L;
+  private static final long NEW_STATE_ID = 2L;
+  private static final long ERROR_ID = 3L;
+
   public ActionsClusterActionFailedEvent(
     Integer actionID,
     Long invokeID,
@@ -156,6 +334,55 @@ public ActionsClusterActionFailedEvent(
     this.error = error;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ACTION_I_D_ID, new UIntType(actionID)));
+    values.add(new StructElement(INVOKE_I_D_ID, new UIntType(invokeID)));
+    values.add(new StructElement(NEW_STATE_ID, new UIntType(newState)));
+    values.add(new StructElement(ERROR_ID, new UIntType(error)));
+
+    return new StructType(values);
+  }
+
+  public static ActionsClusterActionFailedEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer actionID = null;
+    Long invokeID = null;
+    Integer newState = null;
+    Integer error = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ACTION_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          actionID = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == INVOKE_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          invokeID = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == NEW_STATE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          newState = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == ERROR_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          error = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new ActionsClusterActionFailedEvent(
+      actionID,
+      invokeID,
+      newState,
+      error
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -178,12 +405,39 @@ public String toString() {
 }
 public static class BasicInformationClusterStartUpEvent {
   public Long softwareVersion;
+  private static final long SOFTWARE_VERSION_ID = 0L;
+
   public BasicInformationClusterStartUpEvent(
     Long softwareVersion
   ) {
     this.softwareVersion = softwareVersion;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(SOFTWARE_VERSION_ID, new UIntType(softwareVersion)));
+
+    return new StructType(values);
+  }
+
+  public static BasicInformationClusterStartUpEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Long softwareVersion = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == SOFTWARE_VERSION_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          softwareVersion = castingValue.value(Long.class);
+        }
+      }
+    }
+    return new BasicInformationClusterStartUpEvent(
+      softwareVersion
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -197,12 +451,39 @@ public String toString() {
 }
 public static class BasicInformationClusterLeaveEvent {
   public Integer fabricIndex;
+  private static final long FABRIC_INDEX_ID = 0L;
+
   public BasicInformationClusterLeaveEvent(
     Integer fabricIndex
   ) {
     this.fabricIndex = fabricIndex;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(FABRIC_INDEX_ID, new UIntType(fabricIndex)));
+
+    return new StructType(values);
+  }
+
+  public static BasicInformationClusterLeaveEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer fabricIndex = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == FABRIC_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricIndex = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new BasicInformationClusterLeaveEvent(
+      fabricIndex
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -216,12 +497,39 @@ public String toString() {
 }
 public static class BasicInformationClusterReachableChangedEvent {
   public Boolean reachableNewValue;
+  private static final long REACHABLE_NEW_VALUE_ID = 0L;
+
   public BasicInformationClusterReachableChangedEvent(
     Boolean reachableNewValue
   ) {
     this.reachableNewValue = reachableNewValue;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(REACHABLE_NEW_VALUE_ID, new BooleanType(reachableNewValue)));
+
+    return new StructType(values);
+  }
+
+  public static BasicInformationClusterReachableChangedEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Boolean reachableNewValue = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == REACHABLE_NEW_VALUE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          reachableNewValue = castingValue.value(Boolean.class);
+        }
+      }
+    }
+    return new BasicInformationClusterReachableChangedEvent(
+      reachableNewValue
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -238,6 +546,11 @@ public static class OtaSoftwareUpdateRequestorClusterStateTransitionEvent {
   public Integer newState;
   public Integer reason;
   public @Nullable Long targetSoftwareVersion;
+  private static final long PREVIOUS_STATE_ID = 0L;
+  private static final long NEW_STATE_ID = 1L;
+  private static final long REASON_ID = 2L;
+  private static final long TARGET_SOFTWARE_VERSION_ID = 3L;
+
   public OtaSoftwareUpdateRequestorClusterStateTransitionEvent(
     Integer previousState,
     Integer newState,
@@ -250,6 +563,55 @@ public OtaSoftwareUpdateRequestorClusterStateTransitionEvent(
     this.targetSoftwareVersion = targetSoftwareVersion;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(PREVIOUS_STATE_ID, new UIntType(previousState)));
+    values.add(new StructElement(NEW_STATE_ID, new UIntType(newState)));
+    values.add(new StructElement(REASON_ID, new UIntType(reason)));
+    values.add(new StructElement(TARGET_SOFTWARE_VERSION_ID, targetSoftwareVersion != null ? new UIntType(targetSoftwareVersion) : new NullType()));
+
+    return new StructType(values);
+  }
+
+  public static OtaSoftwareUpdateRequestorClusterStateTransitionEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer previousState = null;
+    Integer newState = null;
+    Integer reason = null;
+    @Nullable Long targetSoftwareVersion = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == PREVIOUS_STATE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          previousState = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == NEW_STATE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          newState = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == REASON_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          reason = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == TARGET_SOFTWARE_VERSION_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          targetSoftwareVersion = castingValue.value(Long.class);
+        }
+      }
+    }
+    return new OtaSoftwareUpdateRequestorClusterStateTransitionEvent(
+      previousState,
+      newState,
+      reason,
+      targetSoftwareVersion
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -273,6 +635,9 @@ public String toString() {
 public static class OtaSoftwareUpdateRequestorClusterVersionAppliedEvent {
   public Long softwareVersion;
   public Integer productID;
+  private static final long SOFTWARE_VERSION_ID = 0L;
+  private static final long PRODUCT_I_D_ID = 1L;
+
   public OtaSoftwareUpdateRequestorClusterVersionAppliedEvent(
     Long softwareVersion,
     Integer productID
@@ -281,6 +646,39 @@ public OtaSoftwareUpdateRequestorClusterVersionAppliedEvent(
     this.productID = productID;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(SOFTWARE_VERSION_ID, new UIntType(softwareVersion)));
+    values.add(new StructElement(PRODUCT_I_D_ID, new UIntType(productID)));
+
+    return new StructType(values);
+  }
+
+  public static OtaSoftwareUpdateRequestorClusterVersionAppliedEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Long softwareVersion = null;
+    Integer productID = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == SOFTWARE_VERSION_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          softwareVersion = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == PRODUCT_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          productID = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new OtaSoftwareUpdateRequestorClusterVersionAppliedEvent(
+      softwareVersion,
+      productID
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -300,6 +698,11 @@ public static class OtaSoftwareUpdateRequestorClusterDownloadErrorEvent {
   public Long bytesDownloaded;
   public @Nullable Integer progressPercent;
   public @Nullable Long platformCode;
+  private static final long SOFTWARE_VERSION_ID = 0L;
+  private static final long BYTES_DOWNLOADED_ID = 1L;
+  private static final long PROGRESS_PERCENT_ID = 2L;
+  private static final long PLATFORM_CODE_ID = 3L;
+
   public OtaSoftwareUpdateRequestorClusterDownloadErrorEvent(
     Long softwareVersion,
     Long bytesDownloaded,
@@ -312,6 +715,55 @@ public OtaSoftwareUpdateRequestorClusterDownloadErrorEvent(
     this.platformCode = platformCode;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(SOFTWARE_VERSION_ID, new UIntType(softwareVersion)));
+    values.add(new StructElement(BYTES_DOWNLOADED_ID, new UIntType(bytesDownloaded)));
+    values.add(new StructElement(PROGRESS_PERCENT_ID, progressPercent != null ? new UIntType(progressPercent) : new NullType()));
+    values.add(new StructElement(PLATFORM_CODE_ID, platformCode != null ? new IntType(platformCode) : new NullType()));
+
+    return new StructType(values);
+  }
+
+  public static OtaSoftwareUpdateRequestorClusterDownloadErrorEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Long softwareVersion = null;
+    Long bytesDownloaded = null;
+    @Nullable Integer progressPercent = null;
+    @Nullable Long platformCode = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == SOFTWARE_VERSION_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          softwareVersion = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == BYTES_DOWNLOADED_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          bytesDownloaded = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == PROGRESS_PERCENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          progressPercent = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == PLATFORM_CODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Int) {
+          IntType castingValue = element.value(IntType.class);
+          platformCode = castingValue.value(Long.class);
+        }
+      }
+    }
+    return new OtaSoftwareUpdateRequestorClusterDownloadErrorEvent(
+      softwareVersion,
+      bytesDownloaded,
+      progressPercent,
+      platformCode
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -335,6 +787,9 @@ public String toString() {
 public static class PowerSourceClusterWiredFaultChangeEvent {
   public ArrayList<Integer> current;
   public ArrayList<Integer> previous;
+  private static final long CURRENT_ID = 0L;
+  private static final long PREVIOUS_ID = 1L;
+
   public PowerSourceClusterWiredFaultChangeEvent(
     ArrayList<Integer> current,
     ArrayList<Integer> previous
@@ -343,6 +798,39 @@ public PowerSourceClusterWiredFaultChangeEvent(
     this.previous = previous;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(CURRENT_ID, ArrayType.generateArrayType(current, (elementcurrent) -> new UIntType(elementcurrent))));
+    values.add(new StructElement(PREVIOUS_ID, ArrayType.generateArrayType(previous, (elementprevious) -> new UIntType(elementprevious))));
+
+    return new StructType(values);
+  }
+
+  public static PowerSourceClusterWiredFaultChangeEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    ArrayList<Integer> current = null;
+    ArrayList<Integer> previous = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == CURRENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          current = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == PREVIOUS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          previous = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      }
+    }
+    return new PowerSourceClusterWiredFaultChangeEvent(
+      current,
+      previous
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -360,6 +848,9 @@ public String toString() {
 public static class PowerSourceClusterBatFaultChangeEvent {
   public ArrayList<Integer> current;
   public ArrayList<Integer> previous;
+  private static final long CURRENT_ID = 0L;
+  private static final long PREVIOUS_ID = 1L;
+
   public PowerSourceClusterBatFaultChangeEvent(
     ArrayList<Integer> current,
     ArrayList<Integer> previous
@@ -368,6 +859,39 @@ public PowerSourceClusterBatFaultChangeEvent(
     this.previous = previous;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(CURRENT_ID, ArrayType.generateArrayType(current, (elementcurrent) -> new UIntType(elementcurrent))));
+    values.add(new StructElement(PREVIOUS_ID, ArrayType.generateArrayType(previous, (elementprevious) -> new UIntType(elementprevious))));
+
+    return new StructType(values);
+  }
+
+  public static PowerSourceClusterBatFaultChangeEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    ArrayList<Integer> current = null;
+    ArrayList<Integer> previous = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == CURRENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          current = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == PREVIOUS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          previous = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      }
+    }
+    return new PowerSourceClusterBatFaultChangeEvent(
+      current,
+      previous
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -385,6 +909,9 @@ public String toString() {
 public static class PowerSourceClusterBatChargeFaultChangeEvent {
   public ArrayList<Integer> current;
   public ArrayList<Integer> previous;
+  private static final long CURRENT_ID = 0L;
+  private static final long PREVIOUS_ID = 1L;
+
   public PowerSourceClusterBatChargeFaultChangeEvent(
     ArrayList<Integer> current,
     ArrayList<Integer> previous
@@ -393,6 +920,39 @@ public PowerSourceClusterBatChargeFaultChangeEvent(
     this.previous = previous;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(CURRENT_ID, ArrayType.generateArrayType(current, (elementcurrent) -> new UIntType(elementcurrent))));
+    values.add(new StructElement(PREVIOUS_ID, ArrayType.generateArrayType(previous, (elementprevious) -> new UIntType(elementprevious))));
+
+    return new StructType(values);
+  }
+
+  public static PowerSourceClusterBatChargeFaultChangeEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    ArrayList<Integer> current = null;
+    ArrayList<Integer> previous = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == CURRENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          current = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == PREVIOUS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          previous = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      }
+    }
+    return new PowerSourceClusterBatChargeFaultChangeEvent(
+      current,
+      previous
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -410,6 +970,9 @@ public String toString() {
 public static class GeneralDiagnosticsClusterHardwareFaultChangeEvent {
   public ArrayList<Integer> current;
   public ArrayList<Integer> previous;
+  private static final long CURRENT_ID = 0L;
+  private static final long PREVIOUS_ID = 1L;
+
   public GeneralDiagnosticsClusterHardwareFaultChangeEvent(
     ArrayList<Integer> current,
     ArrayList<Integer> previous
@@ -418,6 +981,39 @@ public GeneralDiagnosticsClusterHardwareFaultChangeEvent(
     this.previous = previous;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(CURRENT_ID, ArrayType.generateArrayType(current, (elementcurrent) -> new UIntType(elementcurrent))));
+    values.add(new StructElement(PREVIOUS_ID, ArrayType.generateArrayType(previous, (elementprevious) -> new UIntType(elementprevious))));
+
+    return new StructType(values);
+  }
+
+  public static GeneralDiagnosticsClusterHardwareFaultChangeEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    ArrayList<Integer> current = null;
+    ArrayList<Integer> previous = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == CURRENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          current = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == PREVIOUS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          previous = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      }
+    }
+    return new GeneralDiagnosticsClusterHardwareFaultChangeEvent(
+      current,
+      previous
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -435,6 +1031,9 @@ public String toString() {
 public static class GeneralDiagnosticsClusterRadioFaultChangeEvent {
   public ArrayList<Integer> current;
   public ArrayList<Integer> previous;
+  private static final long CURRENT_ID = 0L;
+  private static final long PREVIOUS_ID = 1L;
+
   public GeneralDiagnosticsClusterRadioFaultChangeEvent(
     ArrayList<Integer> current,
     ArrayList<Integer> previous
@@ -443,6 +1042,39 @@ public GeneralDiagnosticsClusterRadioFaultChangeEvent(
     this.previous = previous;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(CURRENT_ID, ArrayType.generateArrayType(current, (elementcurrent) -> new UIntType(elementcurrent))));
+    values.add(new StructElement(PREVIOUS_ID, ArrayType.generateArrayType(previous, (elementprevious) -> new UIntType(elementprevious))));
+
+    return new StructType(values);
+  }
+
+  public static GeneralDiagnosticsClusterRadioFaultChangeEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    ArrayList<Integer> current = null;
+    ArrayList<Integer> previous = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == CURRENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          current = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == PREVIOUS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          previous = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      }
+    }
+    return new GeneralDiagnosticsClusterRadioFaultChangeEvent(
+      current,
+      previous
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -460,6 +1092,9 @@ public String toString() {
 public static class GeneralDiagnosticsClusterNetworkFaultChangeEvent {
   public ArrayList<Integer> current;
   public ArrayList<Integer> previous;
+  private static final long CURRENT_ID = 0L;
+  private static final long PREVIOUS_ID = 1L;
+
   public GeneralDiagnosticsClusterNetworkFaultChangeEvent(
     ArrayList<Integer> current,
     ArrayList<Integer> previous
@@ -468,6 +1103,39 @@ public GeneralDiagnosticsClusterNetworkFaultChangeEvent(
     this.previous = previous;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(CURRENT_ID, ArrayType.generateArrayType(current, (elementcurrent) -> new UIntType(elementcurrent))));
+    values.add(new StructElement(PREVIOUS_ID, ArrayType.generateArrayType(previous, (elementprevious) -> new UIntType(elementprevious))));
+
+    return new StructType(values);
+  }
+
+  public static GeneralDiagnosticsClusterNetworkFaultChangeEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    ArrayList<Integer> current = null;
+    ArrayList<Integer> previous = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == CURRENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          current = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == PREVIOUS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          previous = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      }
+    }
+    return new GeneralDiagnosticsClusterNetworkFaultChangeEvent(
+      current,
+      previous
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -484,12 +1152,39 @@ public String toString() {
 }
 public static class GeneralDiagnosticsClusterBootReasonEvent {
   public Integer bootReason;
+  private static final long BOOT_REASON_ID = 0L;
+
   public GeneralDiagnosticsClusterBootReasonEvent(
     Integer bootReason
   ) {
     this.bootReason = bootReason;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(BOOT_REASON_ID, new UIntType(bootReason)));
+
+    return new StructType(values);
+  }
+
+  public static GeneralDiagnosticsClusterBootReasonEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer bootReason = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == BOOT_REASON_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          bootReason = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new GeneralDiagnosticsClusterBootReasonEvent(
+      bootReason
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -505,6 +1200,10 @@ public static class SoftwareDiagnosticsClusterSoftwareFaultEvent {
   public Long id;
   public Optional<String> name;
   public Optional<byte[]> faultRecording;
+  private static final long ID_ID = 0L;
+  private static final long NAME_ID = 1L;
+  private static final long FAULT_RECORDING_ID = 2L;
+
   public SoftwareDiagnosticsClusterSoftwareFaultEvent(
     Long id,
     Optional<String> name,
@@ -515,6 +1214,47 @@ public SoftwareDiagnosticsClusterSoftwareFaultEvent(
     this.faultRecording = faultRecording;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ID_ID, new UIntType(id)));
+    values.add(new StructElement(NAME_ID, name.<BaseTLVType>map((nonOptionalname) -> new StringType(nonOptionalname)).orElse(new EmptyType())));
+    values.add(new StructElement(FAULT_RECORDING_ID, faultRecording.<BaseTLVType>map((nonOptionalfaultRecording) -> new ByteArrayType(nonOptionalfaultRecording)).orElse(new EmptyType())));
+
+    return new StructType(values);
+  }
+
+  public static SoftwareDiagnosticsClusterSoftwareFaultEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Long id = null;
+    Optional<String> name = Optional.empty();
+    Optional<byte[]> faultRecording = Optional.empty();
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ID_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          id = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == NAME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          name = Optional.of(castingValue.value(String.class));
+        }
+      } else if (element.contextTagNum() == FAULT_RECORDING_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+          ByteArrayType castingValue = element.value(ByteArrayType.class);
+          faultRecording = Optional.of(castingValue.value(byte[].class));
+        }
+      }
+    }
+    return new SoftwareDiagnosticsClusterSoftwareFaultEvent(
+      id,
+      name,
+      faultRecording
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -534,12 +1274,39 @@ public String toString() {
 }
 public static class ThreadNetworkDiagnosticsClusterConnectionStatusEvent {
   public Integer connectionStatus;
+  private static final long CONNECTION_STATUS_ID = 0L;
+
   public ThreadNetworkDiagnosticsClusterConnectionStatusEvent(
     Integer connectionStatus
   ) {
     this.connectionStatus = connectionStatus;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(CONNECTION_STATUS_ID, new UIntType(connectionStatus)));
+
+    return new StructType(values);
+  }
+
+  public static ThreadNetworkDiagnosticsClusterConnectionStatusEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer connectionStatus = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == CONNECTION_STATUS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          connectionStatus = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new ThreadNetworkDiagnosticsClusterConnectionStatusEvent(
+      connectionStatus
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -554,6 +1321,9 @@ public String toString() {
 public static class ThreadNetworkDiagnosticsClusterNetworkFaultChangeEvent {
   public ArrayList<Integer> current;
   public ArrayList<Integer> previous;
+  private static final long CURRENT_ID = 0L;
+  private static final long PREVIOUS_ID = 1L;
+
   public ThreadNetworkDiagnosticsClusterNetworkFaultChangeEvent(
     ArrayList<Integer> current,
     ArrayList<Integer> previous
@@ -562,6 +1332,39 @@ public ThreadNetworkDiagnosticsClusterNetworkFaultChangeEvent(
     this.previous = previous;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(CURRENT_ID, ArrayType.generateArrayType(current, (elementcurrent) -> new UIntType(elementcurrent))));
+    values.add(new StructElement(PREVIOUS_ID, ArrayType.generateArrayType(previous, (elementprevious) -> new UIntType(elementprevious))));
+
+    return new StructType(values);
+  }
+
+  public static ThreadNetworkDiagnosticsClusterNetworkFaultChangeEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    ArrayList<Integer> current = null;
+    ArrayList<Integer> previous = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == CURRENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          current = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == PREVIOUS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          previous = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      }
+    }
+    return new ThreadNetworkDiagnosticsClusterNetworkFaultChangeEvent(
+      current,
+      previous
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -578,12 +1381,39 @@ public String toString() {
 }
 public static class WiFiNetworkDiagnosticsClusterDisconnectionEvent {
   public Integer reasonCode;
+  private static final long REASON_CODE_ID = 0L;
+
   public WiFiNetworkDiagnosticsClusterDisconnectionEvent(
     Integer reasonCode
   ) {
     this.reasonCode = reasonCode;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(REASON_CODE_ID, new UIntType(reasonCode)));
+
+    return new StructType(values);
+  }
+
+  public static WiFiNetworkDiagnosticsClusterDisconnectionEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer reasonCode = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == REASON_CODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          reasonCode = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new WiFiNetworkDiagnosticsClusterDisconnectionEvent(
+      reasonCode
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -598,6 +1428,9 @@ public String toString() {
 public static class WiFiNetworkDiagnosticsClusterAssociationFailureEvent {
   public Integer associationFailureCause;
   public Integer status;
+  private static final long ASSOCIATION_FAILURE_CAUSE_ID = 0L;
+  private static final long STATUS_ID = 1L;
+
   public WiFiNetworkDiagnosticsClusterAssociationFailureEvent(
     Integer associationFailureCause,
     Integer status
@@ -606,6 +1439,39 @@ public WiFiNetworkDiagnosticsClusterAssociationFailureEvent(
     this.status = status;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ASSOCIATION_FAILURE_CAUSE_ID, new UIntType(associationFailureCause)));
+    values.add(new StructElement(STATUS_ID, new UIntType(status)));
+
+    return new StructType(values);
+  }
+
+  public static WiFiNetworkDiagnosticsClusterAssociationFailureEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer associationFailureCause = null;
+    Integer status = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ASSOCIATION_FAILURE_CAUSE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          associationFailureCause = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == STATUS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          status = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new WiFiNetworkDiagnosticsClusterAssociationFailureEvent(
+      associationFailureCause,
+      status
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -622,12 +1488,39 @@ public String toString() {
 }
 public static class WiFiNetworkDiagnosticsClusterConnectionStatusEvent {
   public Integer connectionStatus;
+  private static final long CONNECTION_STATUS_ID = 0L;
+
   public WiFiNetworkDiagnosticsClusterConnectionStatusEvent(
     Integer connectionStatus
   ) {
     this.connectionStatus = connectionStatus;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(CONNECTION_STATUS_ID, new UIntType(connectionStatus)));
+
+    return new StructType(values);
+  }
+
+  public static WiFiNetworkDiagnosticsClusterConnectionStatusEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer connectionStatus = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == CONNECTION_STATUS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          connectionStatus = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new WiFiNetworkDiagnosticsClusterConnectionStatusEvent(
+      connectionStatus
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -641,12 +1534,39 @@ public String toString() {
 }
 public static class TimeSynchronizationClusterDSTStatusEvent {
   public Boolean DSTOffsetActive;
+  private static final long D_S_T_OFFSET_ACTIVE_ID = 0L;
+
   public TimeSynchronizationClusterDSTStatusEvent(
     Boolean DSTOffsetActive
   ) {
     this.DSTOffsetActive = DSTOffsetActive;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(D_S_T_OFFSET_ACTIVE_ID, new BooleanType(DSTOffsetActive)));
+
+    return new StructType(values);
+  }
+
+  public static TimeSynchronizationClusterDSTStatusEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Boolean DSTOffsetActive = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == D_S_T_OFFSET_ACTIVE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          DSTOffsetActive = castingValue.value(Boolean.class);
+        }
+      }
+    }
+    return new TimeSynchronizationClusterDSTStatusEvent(
+      DSTOffsetActive
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -661,6 +1581,9 @@ public String toString() {
 public static class TimeSynchronizationClusterTimeZoneStatusEvent {
   public Long offset;
   public Optional<String> name;
+  private static final long OFFSET_ID = 0L;
+  private static final long NAME_ID = 1L;
+
   public TimeSynchronizationClusterTimeZoneStatusEvent(
     Long offset,
     Optional<String> name
@@ -669,6 +1592,39 @@ public TimeSynchronizationClusterTimeZoneStatusEvent(
     this.name = name;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(OFFSET_ID, new IntType(offset)));
+    values.add(new StructElement(NAME_ID, name.<BaseTLVType>map((nonOptionalname) -> new StringType(nonOptionalname)).orElse(new EmptyType())));
+
+    return new StructType(values);
+  }
+
+  public static TimeSynchronizationClusterTimeZoneStatusEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Long offset = null;
+    Optional<String> name = Optional.empty();
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == OFFSET_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Int) {
+          IntType castingValue = element.value(IntType.class);
+          offset = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == NAME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          name = Optional.of(castingValue.value(String.class));
+        }
+      }
+    }
+    return new TimeSynchronizationClusterTimeZoneStatusEvent(
+      offset,
+      name
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -685,12 +1641,39 @@ public String toString() {
 }
 public static class BridgedDeviceBasicInformationClusterStartUpEvent {
   public Long softwareVersion;
+  private static final long SOFTWARE_VERSION_ID = 0L;
+
   public BridgedDeviceBasicInformationClusterStartUpEvent(
     Long softwareVersion
   ) {
     this.softwareVersion = softwareVersion;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(SOFTWARE_VERSION_ID, new UIntType(softwareVersion)));
+
+    return new StructType(values);
+  }
+
+  public static BridgedDeviceBasicInformationClusterStartUpEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Long softwareVersion = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == SOFTWARE_VERSION_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          softwareVersion = castingValue.value(Long.class);
+        }
+      }
+    }
+    return new BridgedDeviceBasicInformationClusterStartUpEvent(
+      softwareVersion
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -704,12 +1687,39 @@ public String toString() {
 }
 public static class BridgedDeviceBasicInformationClusterReachableChangedEvent {
   public Boolean reachableNewValue;
+  private static final long REACHABLE_NEW_VALUE_ID = 0L;
+
   public BridgedDeviceBasicInformationClusterReachableChangedEvent(
     Boolean reachableNewValue
   ) {
     this.reachableNewValue = reachableNewValue;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(REACHABLE_NEW_VALUE_ID, new BooleanType(reachableNewValue)));
+
+    return new StructType(values);
+  }
+
+  public static BridgedDeviceBasicInformationClusterReachableChangedEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Boolean reachableNewValue = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == REACHABLE_NEW_VALUE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          reachableNewValue = castingValue.value(Boolean.class);
+        }
+      }
+    }
+    return new BridgedDeviceBasicInformationClusterReachableChangedEvent(
+      reachableNewValue
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -723,12 +1733,39 @@ public String toString() {
 }
 public static class SwitchClusterSwitchLatchedEvent {
   public Integer newPosition;
+  private static final long NEW_POSITION_ID = 0L;
+
   public SwitchClusterSwitchLatchedEvent(
     Integer newPosition
   ) {
     this.newPosition = newPosition;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(NEW_POSITION_ID, new UIntType(newPosition)));
+
+    return new StructType(values);
+  }
+
+  public static SwitchClusterSwitchLatchedEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer newPosition = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == NEW_POSITION_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          newPosition = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new SwitchClusterSwitchLatchedEvent(
+      newPosition
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -742,12 +1779,39 @@ public String toString() {
 }
 public static class SwitchClusterInitialPressEvent {
   public Integer newPosition;
+  private static final long NEW_POSITION_ID = 0L;
+
   public SwitchClusterInitialPressEvent(
     Integer newPosition
   ) {
     this.newPosition = newPosition;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(NEW_POSITION_ID, new UIntType(newPosition)));
+
+    return new StructType(values);
+  }
+
+  public static SwitchClusterInitialPressEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer newPosition = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == NEW_POSITION_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          newPosition = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new SwitchClusterInitialPressEvent(
+      newPosition
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -761,12 +1825,39 @@ public String toString() {
 }
 public static class SwitchClusterLongPressEvent {
   public Integer newPosition;
+  private static final long NEW_POSITION_ID = 0L;
+
   public SwitchClusterLongPressEvent(
     Integer newPosition
   ) {
     this.newPosition = newPosition;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(NEW_POSITION_ID, new UIntType(newPosition)));
+
+    return new StructType(values);
+  }
+
+  public static SwitchClusterLongPressEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer newPosition = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == NEW_POSITION_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          newPosition = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new SwitchClusterLongPressEvent(
+      newPosition
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -780,12 +1871,39 @@ public String toString() {
 }
 public static class SwitchClusterShortReleaseEvent {
   public Integer previousPosition;
+  private static final long PREVIOUS_POSITION_ID = 0L;
+
   public SwitchClusterShortReleaseEvent(
     Integer previousPosition
   ) {
     this.previousPosition = previousPosition;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(PREVIOUS_POSITION_ID, new UIntType(previousPosition)));
+
+    return new StructType(values);
+  }
+
+  public static SwitchClusterShortReleaseEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer previousPosition = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == PREVIOUS_POSITION_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          previousPosition = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new SwitchClusterShortReleaseEvent(
+      previousPosition
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -799,12 +1917,39 @@ public String toString() {
 }
 public static class SwitchClusterLongReleaseEvent {
   public Integer previousPosition;
+  private static final long PREVIOUS_POSITION_ID = 0L;
+
   public SwitchClusterLongReleaseEvent(
     Integer previousPosition
   ) {
     this.previousPosition = previousPosition;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(PREVIOUS_POSITION_ID, new UIntType(previousPosition)));
+
+    return new StructType(values);
+  }
+
+  public static SwitchClusterLongReleaseEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer previousPosition = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == PREVIOUS_POSITION_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          previousPosition = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new SwitchClusterLongReleaseEvent(
+      previousPosition
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -819,6 +1964,9 @@ public String toString() {
 public static class SwitchClusterMultiPressOngoingEvent {
   public Integer newPosition;
   public Integer currentNumberOfPressesCounted;
+  private static final long NEW_POSITION_ID = 0L;
+  private static final long CURRENT_NUMBER_OF_PRESSES_COUNTED_ID = 1L;
+
   public SwitchClusterMultiPressOngoingEvent(
     Integer newPosition,
     Integer currentNumberOfPressesCounted
@@ -827,6 +1975,39 @@ public SwitchClusterMultiPressOngoingEvent(
     this.currentNumberOfPressesCounted = currentNumberOfPressesCounted;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(NEW_POSITION_ID, new UIntType(newPosition)));
+    values.add(new StructElement(CURRENT_NUMBER_OF_PRESSES_COUNTED_ID, new UIntType(currentNumberOfPressesCounted)));
+
+    return new StructType(values);
+  }
+
+  public static SwitchClusterMultiPressOngoingEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer newPosition = null;
+    Integer currentNumberOfPressesCounted = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == NEW_POSITION_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          newPosition = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == CURRENT_NUMBER_OF_PRESSES_COUNTED_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          currentNumberOfPressesCounted = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new SwitchClusterMultiPressOngoingEvent(
+      newPosition,
+      currentNumberOfPressesCounted
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -844,6 +2025,9 @@ public String toString() {
 public static class SwitchClusterMultiPressCompleteEvent {
   public Integer previousPosition;
   public Integer totalNumberOfPressesCounted;
+  private static final long PREVIOUS_POSITION_ID = 0L;
+  private static final long TOTAL_NUMBER_OF_PRESSES_COUNTED_ID = 1L;
+
   public SwitchClusterMultiPressCompleteEvent(
     Integer previousPosition,
     Integer totalNumberOfPressesCounted
@@ -852,6 +2036,39 @@ public SwitchClusterMultiPressCompleteEvent(
     this.totalNumberOfPressesCounted = totalNumberOfPressesCounted;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(PREVIOUS_POSITION_ID, new UIntType(previousPosition)));
+    values.add(new StructElement(TOTAL_NUMBER_OF_PRESSES_COUNTED_ID, new UIntType(totalNumberOfPressesCounted)));
+
+    return new StructType(values);
+  }
+
+  public static SwitchClusterMultiPressCompleteEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer previousPosition = null;
+    Integer totalNumberOfPressesCounted = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == PREVIOUS_POSITION_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          previousPosition = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == TOTAL_NUMBER_OF_PRESSES_COUNTED_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          totalNumberOfPressesCounted = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new SwitchClusterMultiPressCompleteEvent(
+      previousPosition,
+      totalNumberOfPressesCounted
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -868,12 +2085,39 @@ public String toString() {
 }
 public static class BooleanStateClusterStateChangeEvent {
   public Boolean stateValue;
+  private static final long STATE_VALUE_ID = 0L;
+
   public BooleanStateClusterStateChangeEvent(
     Boolean stateValue
   ) {
     this.stateValue = stateValue;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(STATE_VALUE_ID, new BooleanType(stateValue)));
+
+    return new StructType(values);
+  }
+
+  public static BooleanStateClusterStateChangeEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Boolean stateValue = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == STATE_VALUE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          stateValue = castingValue.value(Boolean.class);
+        }
+      }
+    }
+    return new BooleanStateClusterStateChangeEvent(
+      stateValue
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -890,6 +2134,11 @@ public static class RefrigeratorAlarmClusterNotifyEvent {
   public Long inactive;
   public Long state;
   public Long mask;
+  private static final long ACTIVE_ID = 0L;
+  private static final long INACTIVE_ID = 1L;
+  private static final long STATE_ID = 2L;
+  private static final long MASK_ID = 3L;
+
   public RefrigeratorAlarmClusterNotifyEvent(
     Long active,
     Long inactive,
@@ -902,6 +2151,55 @@ public RefrigeratorAlarmClusterNotifyEvent(
     this.mask = mask;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ACTIVE_ID, new UIntType(active)));
+    values.add(new StructElement(INACTIVE_ID, new UIntType(inactive)));
+    values.add(new StructElement(STATE_ID, new UIntType(state)));
+    values.add(new StructElement(MASK_ID, new UIntType(mask)));
+
+    return new StructType(values);
+  }
+
+  public static RefrigeratorAlarmClusterNotifyEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Long active = null;
+    Long inactive = null;
+    Long state = null;
+    Long mask = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ACTIVE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          active = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == INACTIVE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          inactive = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == STATE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          state = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == MASK_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          mask = castingValue.value(Long.class);
+        }
+      }
+    }
+    return new RefrigeratorAlarmClusterNotifyEvent(
+      active,
+      inactive,
+      state,
+      mask
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -924,12 +2222,39 @@ public String toString() {
 }
 public static class SmokeCoAlarmClusterSmokeAlarmEvent {
   public Integer alarmSeverityLevel;
+  private static final long ALARM_SEVERITY_LEVEL_ID = 0L;
+
   public SmokeCoAlarmClusterSmokeAlarmEvent(
     Integer alarmSeverityLevel
   ) {
     this.alarmSeverityLevel = alarmSeverityLevel;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ALARM_SEVERITY_LEVEL_ID, new UIntType(alarmSeverityLevel)));
+
+    return new StructType(values);
+  }
+
+  public static SmokeCoAlarmClusterSmokeAlarmEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer alarmSeverityLevel = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ALARM_SEVERITY_LEVEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          alarmSeverityLevel = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new SmokeCoAlarmClusterSmokeAlarmEvent(
+      alarmSeverityLevel
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -943,12 +2268,39 @@ public String toString() {
 }
 public static class SmokeCoAlarmClusterCOAlarmEvent {
   public Integer alarmSeverityLevel;
+  private static final long ALARM_SEVERITY_LEVEL_ID = 0L;
+
   public SmokeCoAlarmClusterCOAlarmEvent(
     Integer alarmSeverityLevel
   ) {
     this.alarmSeverityLevel = alarmSeverityLevel;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ALARM_SEVERITY_LEVEL_ID, new UIntType(alarmSeverityLevel)));
+
+    return new StructType(values);
+  }
+
+  public static SmokeCoAlarmClusterCOAlarmEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer alarmSeverityLevel = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ALARM_SEVERITY_LEVEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          alarmSeverityLevel = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new SmokeCoAlarmClusterCOAlarmEvent(
+      alarmSeverityLevel
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -962,12 +2314,39 @@ public String toString() {
 }
 public static class SmokeCoAlarmClusterLowBatteryEvent {
   public Integer alarmSeverityLevel;
+  private static final long ALARM_SEVERITY_LEVEL_ID = 0L;
+
   public SmokeCoAlarmClusterLowBatteryEvent(
     Integer alarmSeverityLevel
   ) {
     this.alarmSeverityLevel = alarmSeverityLevel;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ALARM_SEVERITY_LEVEL_ID, new UIntType(alarmSeverityLevel)));
+
+    return new StructType(values);
+  }
+
+  public static SmokeCoAlarmClusterLowBatteryEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer alarmSeverityLevel = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ALARM_SEVERITY_LEVEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          alarmSeverityLevel = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new SmokeCoAlarmClusterLowBatteryEvent(
+      alarmSeverityLevel
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -981,12 +2360,39 @@ public String toString() {
 }
 public static class SmokeCoAlarmClusterInterconnectSmokeAlarmEvent {
   public Integer alarmSeverityLevel;
+  private static final long ALARM_SEVERITY_LEVEL_ID = 0L;
+
   public SmokeCoAlarmClusterInterconnectSmokeAlarmEvent(
     Integer alarmSeverityLevel
   ) {
     this.alarmSeverityLevel = alarmSeverityLevel;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ALARM_SEVERITY_LEVEL_ID, new UIntType(alarmSeverityLevel)));
+
+    return new StructType(values);
+  }
+
+  public static SmokeCoAlarmClusterInterconnectSmokeAlarmEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer alarmSeverityLevel = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ALARM_SEVERITY_LEVEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          alarmSeverityLevel = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new SmokeCoAlarmClusterInterconnectSmokeAlarmEvent(
+      alarmSeverityLevel
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1000,12 +2406,39 @@ public String toString() {
 }
 public static class SmokeCoAlarmClusterInterconnectCOAlarmEvent {
   public Integer alarmSeverityLevel;
+  private static final long ALARM_SEVERITY_LEVEL_ID = 0L;
+
   public SmokeCoAlarmClusterInterconnectCOAlarmEvent(
     Integer alarmSeverityLevel
   ) {
     this.alarmSeverityLevel = alarmSeverityLevel;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ALARM_SEVERITY_LEVEL_ID, new UIntType(alarmSeverityLevel)));
+
+    return new StructType(values);
+  }
+
+  public static SmokeCoAlarmClusterInterconnectCOAlarmEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer alarmSeverityLevel = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ALARM_SEVERITY_LEVEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          alarmSeverityLevel = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new SmokeCoAlarmClusterInterconnectCOAlarmEvent(
+      alarmSeverityLevel
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1022,6 +2455,11 @@ public static class DishwasherAlarmClusterNotifyEvent {
   public Long inactive;
   public Long state;
   public Long mask;
+  private static final long ACTIVE_ID = 0L;
+  private static final long INACTIVE_ID = 1L;
+  private static final long STATE_ID = 2L;
+  private static final long MASK_ID = 3L;
+
   public DishwasherAlarmClusterNotifyEvent(
     Long active,
     Long inactive,
@@ -1034,6 +2472,55 @@ public DishwasherAlarmClusterNotifyEvent(
     this.mask = mask;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ACTIVE_ID, new UIntType(active)));
+    values.add(new StructElement(INACTIVE_ID, new UIntType(inactive)));
+    values.add(new StructElement(STATE_ID, new UIntType(state)));
+    values.add(new StructElement(MASK_ID, new UIntType(mask)));
+
+    return new StructType(values);
+  }
+
+  public static DishwasherAlarmClusterNotifyEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Long active = null;
+    Long inactive = null;
+    Long state = null;
+    Long mask = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ACTIVE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          active = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == INACTIVE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          inactive = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == STATE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          state = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == MASK_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          mask = castingValue.value(Long.class);
+        }
+      }
+    }
+    return new DishwasherAlarmClusterNotifyEvent(
+      active,
+      inactive,
+      state,
+      mask
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1056,12 +2543,39 @@ public String toString() {
 }
 public static class OperationalStateClusterOperationalErrorEvent {
   public ChipStructs.OperationalStateClusterErrorStateStruct errorState;
+  private static final long ERROR_STATE_ID = 0L;
+
   public OperationalStateClusterOperationalErrorEvent(
     ChipStructs.OperationalStateClusterErrorStateStruct errorState
   ) {
     this.errorState = errorState;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ERROR_STATE_ID, errorState.encodeTlv()));
+
+    return new StructType(values);
+  }
+
+  public static OperationalStateClusterOperationalErrorEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    ChipStructs.OperationalStateClusterErrorStateStruct errorState = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ERROR_STATE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+          StructType castingValue = element.value(StructType.class);
+          errorState = ChipStructs.OperationalStateClusterErrorStateStruct.decodeTlv(castingValue);
+        }
+      }
+    }
+    return new OperationalStateClusterOperationalErrorEvent(
+      errorState
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1077,6 +2591,10 @@ public static class OperationalStateClusterOperationCompletionEvent {
   public Integer completionErrorCode;
   public @Nullable Optional<Long> totalOperationalTime;
   public @Nullable Optional<Long> pausedTime;
+  private static final long COMPLETION_ERROR_CODE_ID = 0L;
+  private static final long TOTAL_OPERATIONAL_TIME_ID = 1L;
+  private static final long PAUSED_TIME_ID = 2L;
+
   public OperationalStateClusterOperationCompletionEvent(
     Integer completionErrorCode,
     @Nullable Optional<Long> totalOperationalTime,
@@ -1087,6 +2605,47 @@ public OperationalStateClusterOperationCompletionEvent(
     this.pausedTime = pausedTime;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(COMPLETION_ERROR_CODE_ID, new UIntType(completionErrorCode)));
+    values.add(new StructElement(TOTAL_OPERATIONAL_TIME_ID, totalOperationalTime != null ? totalOperationalTime.<BaseTLVType>map((nonOptionaltotalOperationalTime) -> new UIntType(nonOptionaltotalOperationalTime)).orElse(new EmptyType()) : new NullType()));
+    values.add(new StructElement(PAUSED_TIME_ID, pausedTime != null ? pausedTime.<BaseTLVType>map((nonOptionalpausedTime) -> new UIntType(nonOptionalpausedTime)).orElse(new EmptyType()) : new NullType()));
+
+    return new StructType(values);
+  }
+
+  public static OperationalStateClusterOperationCompletionEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer completionErrorCode = null;
+    @Nullable Optional<Long> totalOperationalTime = null;
+    @Nullable Optional<Long> pausedTime = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == COMPLETION_ERROR_CODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          completionErrorCode = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == TOTAL_OPERATIONAL_TIME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          totalOperationalTime = Optional.of(castingValue.value(Long.class));
+        }
+      } else if (element.contextTagNum() == PAUSED_TIME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          pausedTime = Optional.of(castingValue.value(Long.class));
+        }
+      }
+    }
+    return new OperationalStateClusterOperationCompletionEvent(
+      completionErrorCode,
+      totalOperationalTime,
+      pausedTime
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1106,12 +2665,39 @@ public String toString() {
 }
 public static class RvcOperationalStateClusterOperationalErrorEvent {
   public ChipStructs.RvcOperationalStateClusterErrorStateStruct errorState;
+  private static final long ERROR_STATE_ID = 0L;
+
   public RvcOperationalStateClusterOperationalErrorEvent(
     ChipStructs.RvcOperationalStateClusterErrorStateStruct errorState
   ) {
     this.errorState = errorState;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ERROR_STATE_ID, errorState.encodeTlv()));
+
+    return new StructType(values);
+  }
+
+  public static RvcOperationalStateClusterOperationalErrorEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    ChipStructs.RvcOperationalStateClusterErrorStateStruct errorState = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ERROR_STATE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+          StructType castingValue = element.value(StructType.class);
+          errorState = ChipStructs.RvcOperationalStateClusterErrorStateStruct.decodeTlv(castingValue);
+        }
+      }
+    }
+    return new RvcOperationalStateClusterOperationalErrorEvent(
+      errorState
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1127,6 +2713,10 @@ public static class RvcOperationalStateClusterOperationCompletionEvent {
   public Integer completionErrorCode;
   public @Nullable Optional<Long> totalOperationalTime;
   public @Nullable Optional<Long> pausedTime;
+  private static final long COMPLETION_ERROR_CODE_ID = 0L;
+  private static final long TOTAL_OPERATIONAL_TIME_ID = 1L;
+  private static final long PAUSED_TIME_ID = 2L;
+
   public RvcOperationalStateClusterOperationCompletionEvent(
     Integer completionErrorCode,
     @Nullable Optional<Long> totalOperationalTime,
@@ -1137,6 +2727,47 @@ public RvcOperationalStateClusterOperationCompletionEvent(
     this.pausedTime = pausedTime;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(COMPLETION_ERROR_CODE_ID, new UIntType(completionErrorCode)));
+    values.add(new StructElement(TOTAL_OPERATIONAL_TIME_ID, totalOperationalTime != null ? totalOperationalTime.<BaseTLVType>map((nonOptionaltotalOperationalTime) -> new UIntType(nonOptionaltotalOperationalTime)).orElse(new EmptyType()) : new NullType()));
+    values.add(new StructElement(PAUSED_TIME_ID, pausedTime != null ? pausedTime.<BaseTLVType>map((nonOptionalpausedTime) -> new UIntType(nonOptionalpausedTime)).orElse(new EmptyType()) : new NullType()));
+
+    return new StructType(values);
+  }
+
+  public static RvcOperationalStateClusterOperationCompletionEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer completionErrorCode = null;
+    @Nullable Optional<Long> totalOperationalTime = null;
+    @Nullable Optional<Long> pausedTime = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == COMPLETION_ERROR_CODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          completionErrorCode = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == TOTAL_OPERATIONAL_TIME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          totalOperationalTime = Optional.of(castingValue.value(Long.class));
+        }
+      } else if (element.contextTagNum() == PAUSED_TIME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          pausedTime = Optional.of(castingValue.value(Long.class));
+        }
+      }
+    }
+    return new RvcOperationalStateClusterOperationCompletionEvent(
+      completionErrorCode,
+      totalOperationalTime,
+      pausedTime
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1156,12 +2787,39 @@ public String toString() {
 }
 public static class DoorLockClusterDoorLockAlarmEvent {
   public Integer alarmCode;
+  private static final long ALARM_CODE_ID = 0L;
+
   public DoorLockClusterDoorLockAlarmEvent(
     Integer alarmCode
   ) {
     this.alarmCode = alarmCode;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ALARM_CODE_ID, new UIntType(alarmCode)));
+
+    return new StructType(values);
+  }
+
+  public static DoorLockClusterDoorLockAlarmEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer alarmCode = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ALARM_CODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          alarmCode = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new DoorLockClusterDoorLockAlarmEvent(
+      alarmCode
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1175,12 +2833,39 @@ public String toString() {
 }
 public static class DoorLockClusterDoorStateChangeEvent {
   public Integer doorState;
+  private static final long DOOR_STATE_ID = 0L;
+
   public DoorLockClusterDoorStateChangeEvent(
     Integer doorState
   ) {
     this.doorState = doorState;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(DOOR_STATE_ID, new UIntType(doorState)));
+
+    return new StructType(values);
+  }
+
+  public static DoorLockClusterDoorStateChangeEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer doorState = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == DOOR_STATE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          doorState = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new DoorLockClusterDoorStateChangeEvent(
+      doorState
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1199,6 +2884,13 @@ public static class DoorLockClusterLockOperationEvent {
   public @Nullable Integer fabricIndex;
   public @Nullable Long sourceNode;
   public @Nullable Optional<ArrayList<ChipStructs.DoorLockClusterCredentialStruct>> credentials;
+  private static final long LOCK_OPERATION_TYPE_ID = 0L;
+  private static final long OPERATION_SOURCE_ID = 1L;
+  private static final long USER_INDEX_ID = 2L;
+  private static final long FABRIC_INDEX_ID = 3L;
+  private static final long SOURCE_NODE_ID = 4L;
+  private static final long CREDENTIALS_ID = 5L;
+
   public DoorLockClusterLockOperationEvent(
     Integer lockOperationType,
     Integer operationSource,
@@ -1215,6 +2907,71 @@ public DoorLockClusterLockOperationEvent(
     this.credentials = credentials;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(LOCK_OPERATION_TYPE_ID, new UIntType(lockOperationType)));
+    values.add(new StructElement(OPERATION_SOURCE_ID, new UIntType(operationSource)));
+    values.add(new StructElement(USER_INDEX_ID, userIndex != null ? new UIntType(userIndex) : new NullType()));
+    values.add(new StructElement(FABRIC_INDEX_ID, fabricIndex != null ? new UIntType(fabricIndex) : new NullType()));
+    values.add(new StructElement(SOURCE_NODE_ID, sourceNode != null ? new UIntType(sourceNode) : new NullType()));
+    values.add(new StructElement(CREDENTIALS_ID, credentials != null ? credentials.<BaseTLVType>map((nonOptionalcredentials) -> ArrayType.generateArrayType(nonOptionalcredentials, (elementnonOptionalcredentials) -> elementnonOptionalcredentials.encodeTlv())).orElse(new EmptyType()) : new NullType()));
+
+    return new StructType(values);
+  }
+
+  public static DoorLockClusterLockOperationEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer lockOperationType = null;
+    Integer operationSource = null;
+    @Nullable Integer userIndex = null;
+    @Nullable Integer fabricIndex = null;
+    @Nullable Long sourceNode = null;
+    @Nullable Optional<ArrayList<ChipStructs.DoorLockClusterCredentialStruct>> credentials = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == LOCK_OPERATION_TYPE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          lockOperationType = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == OPERATION_SOURCE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          operationSource = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == USER_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          userIndex = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == FABRIC_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricIndex = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == SOURCE_NODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          sourceNode = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == CREDENTIALS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          credentials = Optional.of(castingValue.map((elementcastingValue) -> ChipStructs.DoorLockClusterCredentialStruct.decodeTlv(elementcastingValue)));
+        }
+      }
+    }
+    return new DoorLockClusterLockOperationEvent(
+      lockOperationType,
+      operationSource,
+      userIndex,
+      fabricIndex,
+      sourceNode,
+      credentials
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1249,6 +3006,14 @@ public static class DoorLockClusterLockOperationErrorEvent {
   public @Nullable Integer fabricIndex;
   public @Nullable Long sourceNode;
   public @Nullable Optional<ArrayList<ChipStructs.DoorLockClusterCredentialStruct>> credentials;
+  private static final long LOCK_OPERATION_TYPE_ID = 0L;
+  private static final long OPERATION_SOURCE_ID = 1L;
+  private static final long OPERATION_ERROR_ID = 2L;
+  private static final long USER_INDEX_ID = 3L;
+  private static final long FABRIC_INDEX_ID = 4L;
+  private static final long SOURCE_NODE_ID = 5L;
+  private static final long CREDENTIALS_ID = 6L;
+
   public DoorLockClusterLockOperationErrorEvent(
     Integer lockOperationType,
     Integer operationSource,
@@ -1267,6 +3032,79 @@ public DoorLockClusterLockOperationErrorEvent(
     this.credentials = credentials;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(LOCK_OPERATION_TYPE_ID, new UIntType(lockOperationType)));
+    values.add(new StructElement(OPERATION_SOURCE_ID, new UIntType(operationSource)));
+    values.add(new StructElement(OPERATION_ERROR_ID, new UIntType(operationError)));
+    values.add(new StructElement(USER_INDEX_ID, userIndex != null ? new UIntType(userIndex) : new NullType()));
+    values.add(new StructElement(FABRIC_INDEX_ID, fabricIndex != null ? new UIntType(fabricIndex) : new NullType()));
+    values.add(new StructElement(SOURCE_NODE_ID, sourceNode != null ? new UIntType(sourceNode) : new NullType()));
+    values.add(new StructElement(CREDENTIALS_ID, credentials != null ? credentials.<BaseTLVType>map((nonOptionalcredentials) -> ArrayType.generateArrayType(nonOptionalcredentials, (elementnonOptionalcredentials) -> elementnonOptionalcredentials.encodeTlv())).orElse(new EmptyType()) : new NullType()));
+
+    return new StructType(values);
+  }
+
+  public static DoorLockClusterLockOperationErrorEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer lockOperationType = null;
+    Integer operationSource = null;
+    Integer operationError = null;
+    @Nullable Integer userIndex = null;
+    @Nullable Integer fabricIndex = null;
+    @Nullable Long sourceNode = null;
+    @Nullable Optional<ArrayList<ChipStructs.DoorLockClusterCredentialStruct>> credentials = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == LOCK_OPERATION_TYPE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          lockOperationType = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == OPERATION_SOURCE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          operationSource = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == OPERATION_ERROR_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          operationError = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == USER_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          userIndex = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == FABRIC_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricIndex = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == SOURCE_NODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          sourceNode = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == CREDENTIALS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          credentials = Optional.of(castingValue.map((elementcastingValue) -> ChipStructs.DoorLockClusterCredentialStruct.decodeTlv(elementcastingValue)));
+        }
+      }
+    }
+    return new DoorLockClusterLockOperationErrorEvent(
+      lockOperationType,
+      operationSource,
+      operationError,
+      userIndex,
+      fabricIndex,
+      sourceNode,
+      credentials
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1304,6 +3142,14 @@ public static class DoorLockClusterLockUserChangeEvent {
   public @Nullable Integer fabricIndex;
   public @Nullable Long sourceNode;
   public @Nullable Integer dataIndex;
+  private static final long LOCK_DATA_TYPE_ID = 0L;
+  private static final long DATA_OPERATION_TYPE_ID = 1L;
+  private static final long OPERATION_SOURCE_ID = 2L;
+  private static final long USER_INDEX_ID = 3L;
+  private static final long FABRIC_INDEX_ID = 4L;
+  private static final long SOURCE_NODE_ID = 5L;
+  private static final long DATA_INDEX_ID = 6L;
+
   public DoorLockClusterLockUserChangeEvent(
     Integer lockDataType,
     Integer dataOperationType,
@@ -1322,6 +3168,79 @@ public DoorLockClusterLockUserChangeEvent(
     this.dataIndex = dataIndex;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(LOCK_DATA_TYPE_ID, new UIntType(lockDataType)));
+    values.add(new StructElement(DATA_OPERATION_TYPE_ID, new UIntType(dataOperationType)));
+    values.add(new StructElement(OPERATION_SOURCE_ID, new UIntType(operationSource)));
+    values.add(new StructElement(USER_INDEX_ID, userIndex != null ? new UIntType(userIndex) : new NullType()));
+    values.add(new StructElement(FABRIC_INDEX_ID, fabricIndex != null ? new UIntType(fabricIndex) : new NullType()));
+    values.add(new StructElement(SOURCE_NODE_ID, sourceNode != null ? new UIntType(sourceNode) : new NullType()));
+    values.add(new StructElement(DATA_INDEX_ID, dataIndex != null ? new UIntType(dataIndex) : new NullType()));
+
+    return new StructType(values);
+  }
+
+  public static DoorLockClusterLockUserChangeEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer lockDataType = null;
+    Integer dataOperationType = null;
+    Integer operationSource = null;
+    @Nullable Integer userIndex = null;
+    @Nullable Integer fabricIndex = null;
+    @Nullable Long sourceNode = null;
+    @Nullable Integer dataIndex = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == LOCK_DATA_TYPE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          lockDataType = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == DATA_OPERATION_TYPE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          dataOperationType = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == OPERATION_SOURCE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          operationSource = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == USER_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          userIndex = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == FABRIC_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricIndex = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == SOURCE_NODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          sourceNode = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == DATA_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          dataIndex = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new DoorLockClusterLockUserChangeEvent(
+      lockDataType,
+      dataOperationType,
+      operationSource,
+      userIndex,
+      fabricIndex,
+      sourceNode,
+      dataIndex
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1358,6 +3277,13 @@ public static class UnitTestingClusterTestEventEvent {
   public ChipStructs.UnitTestingClusterSimpleStruct arg4;
   public ArrayList<ChipStructs.UnitTestingClusterSimpleStruct> arg5;
   public ArrayList<Integer> arg6;
+  private static final long ARG1_ID = 1L;
+  private static final long ARG2_ID = 2L;
+  private static final long ARG3_ID = 3L;
+  private static final long ARG4_ID = 4L;
+  private static final long ARG5_ID = 5L;
+  private static final long ARG6_ID = 6L;
+
   public UnitTestingClusterTestEventEvent(
     Integer arg1,
     Integer arg2,
@@ -1374,6 +3300,71 @@ public UnitTestingClusterTestEventEvent(
     this.arg6 = arg6;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ARG1_ID, new UIntType(arg1)));
+    values.add(new StructElement(ARG2_ID, new UIntType(arg2)));
+    values.add(new StructElement(ARG3_ID, new BooleanType(arg3)));
+    values.add(new StructElement(ARG4_ID, arg4.encodeTlv()));
+    values.add(new StructElement(ARG5_ID, ArrayType.generateArrayType(arg5, (elementarg5) -> elementarg5.encodeTlv())));
+    values.add(new StructElement(ARG6_ID, ArrayType.generateArrayType(arg6, (elementarg6) -> new UIntType(elementarg6))));
+
+    return new StructType(values);
+  }
+
+  public static UnitTestingClusterTestEventEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer arg1 = null;
+    Integer arg2 = null;
+    Boolean arg3 = null;
+    ChipStructs.UnitTestingClusterSimpleStruct arg4 = null;
+    ArrayList<ChipStructs.UnitTestingClusterSimpleStruct> arg5 = null;
+    ArrayList<Integer> arg6 = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ARG1_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          arg1 = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == ARG2_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          arg2 = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == ARG3_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          arg3 = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == ARG4_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+          StructType castingValue = element.value(StructType.class);
+          arg4 = ChipStructs.UnitTestingClusterSimpleStruct.decodeTlv(castingValue);
+        }
+      } else if (element.contextTagNum() == ARG5_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          arg5 = castingValue.map((elementcastingValue) -> ChipStructs.UnitTestingClusterSimpleStruct.decodeTlv(elementcastingValue));
+        }
+      } else if (element.contextTagNum() == ARG6_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          arg6 = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      }
+    }
+    return new UnitTestingClusterTestEventEvent(
+      arg1,
+      arg2,
+      arg3,
+      arg4,
+      arg5,
+      arg6
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1402,12 +3393,39 @@ public String toString() {
 }
 public static class UnitTestingClusterTestFabricScopedEventEvent {
   public Integer fabricIndex;
+  private static final long FABRIC_INDEX_ID = 254L;
+
   public UnitTestingClusterTestFabricScopedEventEvent(
     Integer fabricIndex
   ) {
     this.fabricIndex = fabricIndex;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(FABRIC_INDEX_ID, new UIntType(fabricIndex)));
+
+    return new StructType(values);
+  }
+
+  public static UnitTestingClusterTestFabricScopedEventEvent decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer fabricIndex = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == FABRIC_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricIndex = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new UnitTestingClusterTestFabricScopedEventEvent(
+      fabricIndex
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
diff --git a/src/controller/java/generated/java/chip/devicecontroller/ChipStructs.java b/src/controller/java/generated/java/chip/devicecontroller/ChipStructs.java
index 52c8d1f85958bf..f34eba0b02ef69 100644
--- a/src/controller/java/generated/java/chip/devicecontroller/ChipStructs.java
+++ b/src/controller/java/generated/java/chip/devicecontroller/ChipStructs.java
@@ -21,10 +21,15 @@
 import java.util.Arrays;
 import java.util.Optional;
 
+import static chip.devicecontroller.ChipTLVType.*;
+
 public class ChipStructs {
 public static class ScenesClusterAttributeValuePair {
   public Long attributeID;
   public Long attributeValue;
+  private static final long ATTRIBUTE_I_D_ID = 0L;
+  private static final long ATTRIBUTE_VALUE_ID = 1L;
+
   public ScenesClusterAttributeValuePair(
     Long attributeID,
     Long attributeValue
@@ -33,6 +38,39 @@ public ScenesClusterAttributeValuePair(
     this.attributeValue = attributeValue;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ATTRIBUTE_I_D_ID, new UIntType(attributeID)));
+    values.add(new StructElement(ATTRIBUTE_VALUE_ID, new UIntType(attributeValue)));
+
+    return new StructType(values);
+  }
+
+  public static ScenesClusterAttributeValuePair decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Long attributeID = null;
+    Long attributeValue = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ATTRIBUTE_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          attributeID = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == ATTRIBUTE_VALUE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          attributeValue = castingValue.value(Long.class);
+        }
+      }
+    }
+    return new ScenesClusterAttributeValuePair(
+      attributeID,
+      attributeValue
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -50,6 +88,9 @@ public String toString() {
 public static class ScenesClusterExtensionFieldSet {
   public Long clusterID;
   public ArrayList<ChipStructs.ScenesClusterAttributeValuePair> attributeValueList;
+  private static final long CLUSTER_I_D_ID = 0L;
+  private static final long ATTRIBUTE_VALUE_LIST_ID = 1L;
+
   public ScenesClusterExtensionFieldSet(
     Long clusterID,
     ArrayList<ChipStructs.ScenesClusterAttributeValuePair> attributeValueList
@@ -58,6 +99,39 @@ public ScenesClusterExtensionFieldSet(
     this.attributeValueList = attributeValueList;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(CLUSTER_I_D_ID, new UIntType(clusterID)));
+    values.add(new StructElement(ATTRIBUTE_VALUE_LIST_ID, ArrayType.generateArrayType(attributeValueList, (elementattributeValueList) -> elementattributeValueList.encodeTlv())));
+
+    return new StructType(values);
+  }
+
+  public static ScenesClusterExtensionFieldSet decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Long clusterID = null;
+    ArrayList<ChipStructs.ScenesClusterAttributeValuePair> attributeValueList = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == CLUSTER_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          clusterID = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == ATTRIBUTE_VALUE_LIST_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          attributeValueList = castingValue.map((elementcastingValue) -> ChipStructs.ScenesClusterAttributeValuePair.decodeTlv(elementcastingValue));
+        }
+      }
+    }
+    return new ScenesClusterExtensionFieldSet(
+      clusterID,
+      attributeValueList
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -75,6 +149,9 @@ public String toString() {
 public static class DescriptorClusterDeviceTypeStruct {
   public Long deviceType;
   public Integer revision;
+  private static final long DEVICE_TYPE_ID = 0L;
+  private static final long REVISION_ID = 1L;
+
   public DescriptorClusterDeviceTypeStruct(
     Long deviceType,
     Integer revision
@@ -83,6 +160,39 @@ public DescriptorClusterDeviceTypeStruct(
     this.revision = revision;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(DEVICE_TYPE_ID, new UIntType(deviceType)));
+    values.add(new StructElement(REVISION_ID, new UIntType(revision)));
+
+    return new StructType(values);
+  }
+
+  public static DescriptorClusterDeviceTypeStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Long deviceType = null;
+    Integer revision = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == DEVICE_TYPE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          deviceType = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == REVISION_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          revision = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new DescriptorClusterDeviceTypeStruct(
+      deviceType,
+      revision
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -102,6 +212,11 @@ public static class DescriptorClusterSemanticTagStruct {
   public Integer namespaceID;
   public Integer tag;
   public @Nullable Optional<String> label;
+  private static final long MFG_CODE_ID = 0L;
+  private static final long NAMESPACE_I_D_ID = 1L;
+  private static final long TAG_ID = 2L;
+  private static final long LABEL_ID = 3L;
+
   public DescriptorClusterSemanticTagStruct(
     @Nullable Integer mfgCode,
     Integer namespaceID,
@@ -114,6 +229,55 @@ public DescriptorClusterSemanticTagStruct(
     this.label = label;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(MFG_CODE_ID, mfgCode != null ? new UIntType(mfgCode) : new NullType()));
+    values.add(new StructElement(NAMESPACE_I_D_ID, new UIntType(namespaceID)));
+    values.add(new StructElement(TAG_ID, new UIntType(tag)));
+    values.add(new StructElement(LABEL_ID, label != null ? label.<BaseTLVType>map((nonOptionallabel) -> new StringType(nonOptionallabel)).orElse(new EmptyType()) : new NullType()));
+
+    return new StructType(values);
+  }
+
+  public static DescriptorClusterSemanticTagStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    @Nullable Integer mfgCode = null;
+    Integer namespaceID = null;
+    Integer tag = null;
+    @Nullable Optional<String> label = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == MFG_CODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          mfgCode = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == NAMESPACE_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          namespaceID = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == TAG_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          tag = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == LABEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          label = Optional.of(castingValue.value(String.class));
+        }
+      }
+    }
+    return new DescriptorClusterSemanticTagStruct(
+      mfgCode,
+      namespaceID,
+      tag,
+      label
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -140,6 +304,12 @@ public static class BindingClusterTargetStruct {
   public Optional<Integer> endpoint;
   public Optional<Long> cluster;
   public Integer fabricIndex;
+  private static final long NODE_ID = 1L;
+  private static final long GROUP_ID = 2L;
+  private static final long ENDPOINT_ID = 3L;
+  private static final long CLUSTER_ID = 4L;
+  private static final long FABRIC_INDEX_ID = 254L;
+
   public BindingClusterTargetStruct(
     Optional<Long> node,
     Optional<Integer> group,
@@ -154,6 +324,63 @@ public BindingClusterTargetStruct(
     this.fabricIndex = fabricIndex;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(NODE_ID, node.<BaseTLVType>map((nonOptionalnode) -> new UIntType(nonOptionalnode)).orElse(new EmptyType())));
+    values.add(new StructElement(GROUP_ID, group.<BaseTLVType>map((nonOptionalgroup) -> new UIntType(nonOptionalgroup)).orElse(new EmptyType())));
+    values.add(new StructElement(ENDPOINT_ID, endpoint.<BaseTLVType>map((nonOptionalendpoint) -> new UIntType(nonOptionalendpoint)).orElse(new EmptyType())));
+    values.add(new StructElement(CLUSTER_ID, cluster.<BaseTLVType>map((nonOptionalcluster) -> new UIntType(nonOptionalcluster)).orElse(new EmptyType())));
+    values.add(new StructElement(FABRIC_INDEX_ID, new UIntType(fabricIndex)));
+
+    return new StructType(values);
+  }
+
+  public static BindingClusterTargetStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Optional<Long> node = Optional.empty();
+    Optional<Integer> group = Optional.empty();
+    Optional<Integer> endpoint = Optional.empty();
+    Optional<Long> cluster = Optional.empty();
+    Integer fabricIndex = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == NODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          node = Optional.of(castingValue.value(Long.class));
+        }
+      } else if (element.contextTagNum() == GROUP_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          group = Optional.of(castingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == ENDPOINT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          endpoint = Optional.of(castingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == CLUSTER_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          cluster = Optional.of(castingValue.value(Long.class));
+        }
+      } else if (element.contextTagNum() == FABRIC_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricIndex = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new BindingClusterTargetStruct(
+      node,
+      group,
+      endpoint,
+      cluster,
+      fabricIndex
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -181,6 +408,10 @@ public static class AccessControlClusterAccessControlTargetStruct {
   public @Nullable Long cluster;
   public @Nullable Integer endpoint;
   public @Nullable Long deviceType;
+  private static final long CLUSTER_ID = 0L;
+  private static final long ENDPOINT_ID = 1L;
+  private static final long DEVICE_TYPE_ID = 2L;
+
   public AccessControlClusterAccessControlTargetStruct(
     @Nullable Long cluster,
     @Nullable Integer endpoint,
@@ -191,6 +422,47 @@ public AccessControlClusterAccessControlTargetStruct(
     this.deviceType = deviceType;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(CLUSTER_ID, cluster != null ? new UIntType(cluster) : new NullType()));
+    values.add(new StructElement(ENDPOINT_ID, endpoint != null ? new UIntType(endpoint) : new NullType()));
+    values.add(new StructElement(DEVICE_TYPE_ID, deviceType != null ? new UIntType(deviceType) : new NullType()));
+
+    return new StructType(values);
+  }
+
+  public static AccessControlClusterAccessControlTargetStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    @Nullable Long cluster = null;
+    @Nullable Integer endpoint = null;
+    @Nullable Long deviceType = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == CLUSTER_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          cluster = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == ENDPOINT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          endpoint = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == DEVICE_TYPE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          deviceType = castingValue.value(Long.class);
+        }
+      }
+    }
+    return new AccessControlClusterAccessControlTargetStruct(
+      cluster,
+      endpoint,
+      deviceType
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -214,6 +486,12 @@ public static class AccessControlClusterAccessControlEntryStruct {
   public @Nullable ArrayList<Long> subjects;
   public @Nullable ArrayList<ChipStructs.AccessControlClusterAccessControlTargetStruct> targets;
   public Integer fabricIndex;
+  private static final long PRIVILEGE_ID = 1L;
+  private static final long AUTH_MODE_ID = 2L;
+  private static final long SUBJECTS_ID = 3L;
+  private static final long TARGETS_ID = 4L;
+  private static final long FABRIC_INDEX_ID = 254L;
+
   public AccessControlClusterAccessControlEntryStruct(
     Integer privilege,
     Integer authMode,
@@ -228,6 +506,63 @@ public AccessControlClusterAccessControlEntryStruct(
     this.fabricIndex = fabricIndex;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(PRIVILEGE_ID, new UIntType(privilege)));
+    values.add(new StructElement(AUTH_MODE_ID, new UIntType(authMode)));
+    values.add(new StructElement(SUBJECTS_ID, subjects != null ? ArrayType.generateArrayType(subjects, (elementsubjects) -> new UIntType(elementsubjects)) : new NullType()));
+    values.add(new StructElement(TARGETS_ID, targets != null ? ArrayType.generateArrayType(targets, (elementtargets) -> elementtargets.encodeTlv()) : new NullType()));
+    values.add(new StructElement(FABRIC_INDEX_ID, new UIntType(fabricIndex)));
+
+    return new StructType(values);
+  }
+
+  public static AccessControlClusterAccessControlEntryStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer privilege = null;
+    Integer authMode = null;
+    @Nullable ArrayList<Long> subjects = null;
+    @Nullable ArrayList<ChipStructs.AccessControlClusterAccessControlTargetStruct> targets = null;
+    Integer fabricIndex = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == PRIVILEGE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          privilege = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == AUTH_MODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          authMode = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == SUBJECTS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          subjects = castingValue.map((elementcastingValue) -> elementcastingValue.value(Long.class));
+        }
+      } else if (element.contextTagNum() == TARGETS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          targets = castingValue.map((elementcastingValue) -> ChipStructs.AccessControlClusterAccessControlTargetStruct.decodeTlv(elementcastingValue));
+        }
+      } else if (element.contextTagNum() == FABRIC_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricIndex = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new AccessControlClusterAccessControlEntryStruct(
+      privilege,
+      authMode,
+      subjects,
+      targets,
+      fabricIndex
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -254,6 +589,9 @@ public String toString() {
 public static class AccessControlClusterAccessControlExtensionStruct {
   public byte[] data;
   public Integer fabricIndex;
+  private static final long DATA_ID = 1L;
+  private static final long FABRIC_INDEX_ID = 254L;
+
   public AccessControlClusterAccessControlExtensionStruct(
     byte[] data,
     Integer fabricIndex
@@ -262,6 +600,39 @@ public AccessControlClusterAccessControlExtensionStruct(
     this.fabricIndex = fabricIndex;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(DATA_ID, new ByteArrayType(data)));
+    values.add(new StructElement(FABRIC_INDEX_ID, new UIntType(fabricIndex)));
+
+    return new StructType(values);
+  }
+
+  public static AccessControlClusterAccessControlExtensionStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    byte[] data = null;
+    Integer fabricIndex = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == DATA_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+          ByteArrayType castingValue = element.value(ByteArrayType.class);
+          data = castingValue.value(byte[].class);
+        }
+      } else if (element.contextTagNum() == FABRIC_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricIndex = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new AccessControlClusterAccessControlExtensionStruct(
+      data,
+      fabricIndex
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -283,6 +654,13 @@ public static class ActionsClusterActionStruct {
   public Integer endpointListID;
   public Integer supportedCommands;
   public Integer state;
+  private static final long ACTION_I_D_ID = 0L;
+  private static final long NAME_ID = 1L;
+  private static final long TYPE_ID = 2L;
+  private static final long ENDPOINT_LIST_I_D_ID = 3L;
+  private static final long SUPPORTED_COMMANDS_ID = 4L;
+  private static final long STATE_ID = 5L;
+
   public ActionsClusterActionStruct(
     Integer actionID,
     String name,
@@ -299,6 +677,71 @@ public ActionsClusterActionStruct(
     this.state = state;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ACTION_I_D_ID, new UIntType(actionID)));
+    values.add(new StructElement(NAME_ID, new StringType(name)));
+    values.add(new StructElement(TYPE_ID, new UIntType(type)));
+    values.add(new StructElement(ENDPOINT_LIST_I_D_ID, new UIntType(endpointListID)));
+    values.add(new StructElement(SUPPORTED_COMMANDS_ID, new UIntType(supportedCommands)));
+    values.add(new StructElement(STATE_ID, new UIntType(state)));
+
+    return new StructType(values);
+  }
+
+  public static ActionsClusterActionStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer actionID = null;
+    String name = null;
+    Integer type = null;
+    Integer endpointListID = null;
+    Integer supportedCommands = null;
+    Integer state = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ACTION_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          actionID = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == NAME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          name = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == TYPE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          type = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == ENDPOINT_LIST_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          endpointListID = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == SUPPORTED_COMMANDS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          supportedCommands = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == STATE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          state = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new ActionsClusterActionStruct(
+      actionID,
+      name,
+      type,
+      endpointListID,
+      supportedCommands,
+      state
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -330,6 +773,11 @@ public static class ActionsClusterEndpointListStruct {
   public String name;
   public Integer type;
   public ArrayList<Integer> endpoints;
+  private static final long ENDPOINT_LIST_I_D_ID = 0L;
+  private static final long NAME_ID = 1L;
+  private static final long TYPE_ID = 2L;
+  private static final long ENDPOINTS_ID = 3L;
+
   public ActionsClusterEndpointListStruct(
     Integer endpointListID,
     String name,
@@ -342,6 +790,55 @@ public ActionsClusterEndpointListStruct(
     this.endpoints = endpoints;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ENDPOINT_LIST_I_D_ID, new UIntType(endpointListID)));
+    values.add(new StructElement(NAME_ID, new StringType(name)));
+    values.add(new StructElement(TYPE_ID, new UIntType(type)));
+    values.add(new StructElement(ENDPOINTS_ID, ArrayType.generateArrayType(endpoints, (elementendpoints) -> new UIntType(elementendpoints))));
+
+    return new StructType(values);
+  }
+
+  public static ActionsClusterEndpointListStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer endpointListID = null;
+    String name = null;
+    Integer type = null;
+    ArrayList<Integer> endpoints = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ENDPOINT_LIST_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          endpointListID = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == NAME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          name = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == TYPE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          type = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == ENDPOINTS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          endpoints = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      }
+    }
+    return new ActionsClusterEndpointListStruct(
+      endpointListID,
+      name,
+      type,
+      endpoints
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -365,6 +862,9 @@ public String toString() {
 public static class BasicInformationClusterCapabilityMinimaStruct {
   public Integer caseSessionsPerFabric;
   public Integer subscriptionsPerFabric;
+  private static final long CASE_SESSIONS_PER_FABRIC_ID = 0L;
+  private static final long SUBSCRIPTIONS_PER_FABRIC_ID = 1L;
+
   public BasicInformationClusterCapabilityMinimaStruct(
     Integer caseSessionsPerFabric,
     Integer subscriptionsPerFabric
@@ -373,6 +873,39 @@ public BasicInformationClusterCapabilityMinimaStruct(
     this.subscriptionsPerFabric = subscriptionsPerFabric;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(CASE_SESSIONS_PER_FABRIC_ID, new UIntType(caseSessionsPerFabric)));
+    values.add(new StructElement(SUBSCRIPTIONS_PER_FABRIC_ID, new UIntType(subscriptionsPerFabric)));
+
+    return new StructType(values);
+  }
+
+  public static BasicInformationClusterCapabilityMinimaStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer caseSessionsPerFabric = null;
+    Integer subscriptionsPerFabric = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == CASE_SESSIONS_PER_FABRIC_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          caseSessionsPerFabric = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == SUBSCRIPTIONS_PER_FABRIC_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          subscriptionsPerFabric = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new BasicInformationClusterCapabilityMinimaStruct(
+      caseSessionsPerFabric,
+      subscriptionsPerFabric
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -390,6 +923,9 @@ public String toString() {
 public static class BasicInformationClusterProductAppearanceStruct {
   public Integer finish;
   public @Nullable Integer primaryColor;
+  private static final long FINISH_ID = 0L;
+  private static final long PRIMARY_COLOR_ID = 1L;
+
   public BasicInformationClusterProductAppearanceStruct(
     Integer finish,
     @Nullable Integer primaryColor
@@ -398,6 +934,39 @@ public BasicInformationClusterProductAppearanceStruct(
     this.primaryColor = primaryColor;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(FINISH_ID, new UIntType(finish)));
+    values.add(new StructElement(PRIMARY_COLOR_ID, primaryColor != null ? new UIntType(primaryColor) : new NullType()));
+
+    return new StructType(values);
+  }
+
+  public static BasicInformationClusterProductAppearanceStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer finish = null;
+    @Nullable Integer primaryColor = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == FINISH_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          finish = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == PRIMARY_COLOR_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          primaryColor = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new BasicInformationClusterProductAppearanceStruct(
+      finish,
+      primaryColor
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -416,6 +985,10 @@ public static class OtaSoftwareUpdateRequestorClusterProviderLocation {
   public Long providerNodeID;
   public Integer endpoint;
   public Integer fabricIndex;
+  private static final long PROVIDER_NODE_I_D_ID = 1L;
+  private static final long ENDPOINT_ID = 2L;
+  private static final long FABRIC_INDEX_ID = 254L;
+
   public OtaSoftwareUpdateRequestorClusterProviderLocation(
     Long providerNodeID,
     Integer endpoint,
@@ -426,6 +999,47 @@ public OtaSoftwareUpdateRequestorClusterProviderLocation(
     this.fabricIndex = fabricIndex;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(PROVIDER_NODE_I_D_ID, new UIntType(providerNodeID)));
+    values.add(new StructElement(ENDPOINT_ID, new UIntType(endpoint)));
+    values.add(new StructElement(FABRIC_INDEX_ID, new UIntType(fabricIndex)));
+
+    return new StructType(values);
+  }
+
+  public static OtaSoftwareUpdateRequestorClusterProviderLocation decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Long providerNodeID = null;
+    Integer endpoint = null;
+    Integer fabricIndex = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == PROVIDER_NODE_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          providerNodeID = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == ENDPOINT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          endpoint = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == FABRIC_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricIndex = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new OtaSoftwareUpdateRequestorClusterProviderLocation(
+      providerNodeID,
+      endpoint,
+      fabricIndex
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -446,6 +1060,9 @@ public String toString() {
 public static class PowerSourceClusterBatChargeFaultChangeType {
   public ArrayList<Integer> current;
   public ArrayList<Integer> previous;
+  private static final long CURRENT_ID = 0L;
+  private static final long PREVIOUS_ID = 1L;
+
   public PowerSourceClusterBatChargeFaultChangeType(
     ArrayList<Integer> current,
     ArrayList<Integer> previous
@@ -454,6 +1071,39 @@ public PowerSourceClusterBatChargeFaultChangeType(
     this.previous = previous;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(CURRENT_ID, ArrayType.generateArrayType(current, (elementcurrent) -> new UIntType(elementcurrent))));
+    values.add(new StructElement(PREVIOUS_ID, ArrayType.generateArrayType(previous, (elementprevious) -> new UIntType(elementprevious))));
+
+    return new StructType(values);
+  }
+
+  public static PowerSourceClusterBatChargeFaultChangeType decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    ArrayList<Integer> current = null;
+    ArrayList<Integer> previous = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == CURRENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          current = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == PREVIOUS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          previous = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      }
+    }
+    return new PowerSourceClusterBatChargeFaultChangeType(
+      current,
+      previous
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -471,6 +1121,9 @@ public String toString() {
 public static class PowerSourceClusterBatFaultChangeType {
   public ArrayList<Integer> current;
   public ArrayList<Integer> previous;
+  private static final long CURRENT_ID = 0L;
+  private static final long PREVIOUS_ID = 1L;
+
   public PowerSourceClusterBatFaultChangeType(
     ArrayList<Integer> current,
     ArrayList<Integer> previous
@@ -479,6 +1132,39 @@ public PowerSourceClusterBatFaultChangeType(
     this.previous = previous;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(CURRENT_ID, ArrayType.generateArrayType(current, (elementcurrent) -> new UIntType(elementcurrent))));
+    values.add(new StructElement(PREVIOUS_ID, ArrayType.generateArrayType(previous, (elementprevious) -> new UIntType(elementprevious))));
+
+    return new StructType(values);
+  }
+
+  public static PowerSourceClusterBatFaultChangeType decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    ArrayList<Integer> current = null;
+    ArrayList<Integer> previous = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == CURRENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          current = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == PREVIOUS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          previous = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      }
+    }
+    return new PowerSourceClusterBatFaultChangeType(
+      current,
+      previous
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -496,6 +1182,9 @@ public String toString() {
 public static class PowerSourceClusterWiredFaultChangeType {
   public ArrayList<Integer> current;
   public ArrayList<Integer> previous;
+  private static final long CURRENT_ID = 0L;
+  private static final long PREVIOUS_ID = 1L;
+
   public PowerSourceClusterWiredFaultChangeType(
     ArrayList<Integer> current,
     ArrayList<Integer> previous
@@ -504,6 +1193,39 @@ public PowerSourceClusterWiredFaultChangeType(
     this.previous = previous;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(CURRENT_ID, ArrayType.generateArrayType(current, (elementcurrent) -> new UIntType(elementcurrent))));
+    values.add(new StructElement(PREVIOUS_ID, ArrayType.generateArrayType(previous, (elementprevious) -> new UIntType(elementprevious))));
+
+    return new StructType(values);
+  }
+
+  public static PowerSourceClusterWiredFaultChangeType decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    ArrayList<Integer> current = null;
+    ArrayList<Integer> previous = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == CURRENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          current = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == PREVIOUS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          previous = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      }
+    }
+    return new PowerSourceClusterWiredFaultChangeType(
+      current,
+      previous
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -521,6 +1243,9 @@ public String toString() {
 public static class GeneralCommissioningClusterBasicCommissioningInfo {
   public Integer failSafeExpiryLengthSeconds;
   public Integer maxCumulativeFailsafeSeconds;
+  private static final long FAIL_SAFE_EXPIRY_LENGTH_SECONDS_ID = 0L;
+  private static final long MAX_CUMULATIVE_FAILSAFE_SECONDS_ID = 1L;
+
   public GeneralCommissioningClusterBasicCommissioningInfo(
     Integer failSafeExpiryLengthSeconds,
     Integer maxCumulativeFailsafeSeconds
@@ -529,6 +1254,39 @@ public GeneralCommissioningClusterBasicCommissioningInfo(
     this.maxCumulativeFailsafeSeconds = maxCumulativeFailsafeSeconds;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(FAIL_SAFE_EXPIRY_LENGTH_SECONDS_ID, new UIntType(failSafeExpiryLengthSeconds)));
+    values.add(new StructElement(MAX_CUMULATIVE_FAILSAFE_SECONDS_ID, new UIntType(maxCumulativeFailsafeSeconds)));
+
+    return new StructType(values);
+  }
+
+  public static GeneralCommissioningClusterBasicCommissioningInfo decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer failSafeExpiryLengthSeconds = null;
+    Integer maxCumulativeFailsafeSeconds = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == FAIL_SAFE_EXPIRY_LENGTH_SECONDS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          failSafeExpiryLengthSeconds = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == MAX_CUMULATIVE_FAILSAFE_SECONDS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          maxCumulativeFailsafeSeconds = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new GeneralCommissioningClusterBasicCommissioningInfo(
+      failSafeExpiryLengthSeconds,
+      maxCumulativeFailsafeSeconds
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -546,6 +1304,9 @@ public String toString() {
 public static class NetworkCommissioningClusterNetworkInfoStruct {
   public byte[] networkID;
   public Boolean connected;
+  private static final long NETWORK_I_D_ID = 0L;
+  private static final long CONNECTED_ID = 1L;
+
   public NetworkCommissioningClusterNetworkInfoStruct(
     byte[] networkID,
     Boolean connected
@@ -554,6 +1315,39 @@ public NetworkCommissioningClusterNetworkInfoStruct(
     this.connected = connected;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(NETWORK_I_D_ID, new ByteArrayType(networkID)));
+    values.add(new StructElement(CONNECTED_ID, new BooleanType(connected)));
+
+    return new StructType(values);
+  }
+
+  public static NetworkCommissioningClusterNetworkInfoStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    byte[] networkID = null;
+    Boolean connected = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == NETWORK_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+          ByteArrayType castingValue = element.value(ByteArrayType.class);
+          networkID = castingValue.value(byte[].class);
+        }
+      } else if (element.contextTagNum() == CONNECTED_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          connected = castingValue.value(Boolean.class);
+        }
+      }
+    }
+    return new NetworkCommissioningClusterNetworkInfoStruct(
+      networkID,
+      connected
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -577,6 +1371,15 @@ public static class NetworkCommissioningClusterThreadInterfaceScanResultStruct {
   public byte[] extendedAddress;
   public Integer rssi;
   public Integer lqi;
+  private static final long PAN_ID_ID = 0L;
+  private static final long EXTENDED_PAN_ID_ID = 1L;
+  private static final long NETWORK_NAME_ID = 2L;
+  private static final long CHANNEL_ID = 3L;
+  private static final long VERSION_ID = 4L;
+  private static final long EXTENDED_ADDRESS_ID = 5L;
+  private static final long RSSI_ID = 6L;
+  private static final long LQI_ID = 7L;
+
   public NetworkCommissioningClusterThreadInterfaceScanResultStruct(
     Integer panId,
     Long extendedPanId,
@@ -597,6 +1400,87 @@ public NetworkCommissioningClusterThreadInterfaceScanResultStruct(
     this.lqi = lqi;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(PAN_ID_ID, new UIntType(panId)));
+    values.add(new StructElement(EXTENDED_PAN_ID_ID, new UIntType(extendedPanId)));
+    values.add(new StructElement(NETWORK_NAME_ID, new StringType(networkName)));
+    values.add(new StructElement(CHANNEL_ID, new UIntType(channel)));
+    values.add(new StructElement(VERSION_ID, new UIntType(version)));
+    values.add(new StructElement(EXTENDED_ADDRESS_ID, new ByteArrayType(extendedAddress)));
+    values.add(new StructElement(RSSI_ID, new IntType(rssi)));
+    values.add(new StructElement(LQI_ID, new UIntType(lqi)));
+
+    return new StructType(values);
+  }
+
+  public static NetworkCommissioningClusterThreadInterfaceScanResultStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer panId = null;
+    Long extendedPanId = null;
+    String networkName = null;
+    Integer channel = null;
+    Integer version = null;
+    byte[] extendedAddress = null;
+    Integer rssi = null;
+    Integer lqi = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == PAN_ID_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          panId = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == EXTENDED_PAN_ID_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          extendedPanId = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == NETWORK_NAME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          networkName = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == CHANNEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          channel = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == VERSION_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          version = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == EXTENDED_ADDRESS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+          ByteArrayType castingValue = element.value(ByteArrayType.class);
+          extendedAddress = castingValue.value(byte[].class);
+        }
+      } else if (element.contextTagNum() == RSSI_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Int) {
+          IntType castingValue = element.value(IntType.class);
+          rssi = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == LQI_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          lqi = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new NetworkCommissioningClusterThreadInterfaceScanResultStruct(
+      panId,
+      extendedPanId,
+      networkName,
+      channel,
+      version,
+      extendedAddress,
+      rssi,
+      lqi
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -636,6 +1520,13 @@ public static class NetworkCommissioningClusterWiFiInterfaceScanResultStruct {
   public Integer channel;
   public Integer wiFiBand;
   public Integer rssi;
+  private static final long SECURITY_ID = 0L;
+  private static final long SSID_ID = 1L;
+  private static final long BSSID_ID = 2L;
+  private static final long CHANNEL_ID = 3L;
+  private static final long WI_FI_BAND_ID = 4L;
+  private static final long RSSI_ID = 5L;
+
   public NetworkCommissioningClusterWiFiInterfaceScanResultStruct(
     Integer security,
     byte[] ssid,
@@ -652,6 +1543,71 @@ public NetworkCommissioningClusterWiFiInterfaceScanResultStruct(
     this.rssi = rssi;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(SECURITY_ID, new UIntType(security)));
+    values.add(new StructElement(SSID_ID, new ByteArrayType(ssid)));
+    values.add(new StructElement(BSSID_ID, new ByteArrayType(bssid)));
+    values.add(new StructElement(CHANNEL_ID, new UIntType(channel)));
+    values.add(new StructElement(WI_FI_BAND_ID, new UIntType(wiFiBand)));
+    values.add(new StructElement(RSSI_ID, new IntType(rssi)));
+
+    return new StructType(values);
+  }
+
+  public static NetworkCommissioningClusterWiFiInterfaceScanResultStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer security = null;
+    byte[] ssid = null;
+    byte[] bssid = null;
+    Integer channel = null;
+    Integer wiFiBand = null;
+    Integer rssi = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == SECURITY_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          security = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == SSID_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+          ByteArrayType castingValue = element.value(ByteArrayType.class);
+          ssid = castingValue.value(byte[].class);
+        }
+      } else if (element.contextTagNum() == BSSID_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+          ByteArrayType castingValue = element.value(ByteArrayType.class);
+          bssid = castingValue.value(byte[].class);
+        }
+      } else if (element.contextTagNum() == CHANNEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          channel = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == WI_FI_BAND_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          wiFiBand = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == RSSI_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Int) {
+          IntType castingValue = element.value(IntType.class);
+          rssi = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new NetworkCommissioningClusterWiFiInterfaceScanResultStruct(
+      security,
+      ssid,
+      bssid,
+      channel,
+      wiFiBand,
+      rssi
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -687,6 +1643,15 @@ public static class GeneralDiagnosticsClusterNetworkInterface {
   public ArrayList<byte[]> IPv4Addresses;
   public ArrayList<byte[]> IPv6Addresses;
   public Integer type;
+  private static final long NAME_ID = 0L;
+  private static final long IS_OPERATIONAL_ID = 1L;
+  private static final long OFF_PREMISE_SERVICES_REACHABLE_I_PV4_ID = 2L;
+  private static final long OFF_PREMISE_SERVICES_REACHABLE_I_PV6_ID = 3L;
+  private static final long HARDWARE_ADDRESS_ID = 4L;
+  private static final long I_PV4_ADDRESSES_ID = 5L;
+  private static final long I_PV6_ADDRESSES_ID = 6L;
+  private static final long TYPE_ID = 7L;
+
   public GeneralDiagnosticsClusterNetworkInterface(
     String name,
     Boolean isOperational,
@@ -707,6 +1672,87 @@ public GeneralDiagnosticsClusterNetworkInterface(
     this.type = type;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(NAME_ID, new StringType(name)));
+    values.add(new StructElement(IS_OPERATIONAL_ID, new BooleanType(isOperational)));
+    values.add(new StructElement(OFF_PREMISE_SERVICES_REACHABLE_I_PV4_ID, offPremiseServicesReachableIPv4 != null ? new BooleanType(offPremiseServicesReachableIPv4) : new NullType()));
+    values.add(new StructElement(OFF_PREMISE_SERVICES_REACHABLE_I_PV6_ID, offPremiseServicesReachableIPv6 != null ? new BooleanType(offPremiseServicesReachableIPv6) : new NullType()));
+    values.add(new StructElement(HARDWARE_ADDRESS_ID, new ByteArrayType(hardwareAddress)));
+    values.add(new StructElement(I_PV4_ADDRESSES_ID, ArrayType.generateArrayType(IPv4Addresses, (elementIPv4Addresses) -> new ByteArrayType(elementIPv4Addresses))));
+    values.add(new StructElement(I_PV6_ADDRESSES_ID, ArrayType.generateArrayType(IPv6Addresses, (elementIPv6Addresses) -> new ByteArrayType(elementIPv6Addresses))));
+    values.add(new StructElement(TYPE_ID, new UIntType(type)));
+
+    return new StructType(values);
+  }
+
+  public static GeneralDiagnosticsClusterNetworkInterface decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    String name = null;
+    Boolean isOperational = null;
+    @Nullable Boolean offPremiseServicesReachableIPv4 = null;
+    @Nullable Boolean offPremiseServicesReachableIPv6 = null;
+    byte[] hardwareAddress = null;
+    ArrayList<byte[]> IPv4Addresses = null;
+    ArrayList<byte[]> IPv6Addresses = null;
+    Integer type = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == NAME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          name = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == IS_OPERATIONAL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          isOperational = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == OFF_PREMISE_SERVICES_REACHABLE_I_PV4_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          offPremiseServicesReachableIPv4 = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == OFF_PREMISE_SERVICES_REACHABLE_I_PV6_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          offPremiseServicesReachableIPv6 = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == HARDWARE_ADDRESS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+          ByteArrayType castingValue = element.value(ByteArrayType.class);
+          hardwareAddress = castingValue.value(byte[].class);
+        }
+      } else if (element.contextTagNum() == I_PV4_ADDRESSES_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          IPv4Addresses = castingValue.map((elementcastingValue) -> elementcastingValue.value(byte[].class));
+        }
+      } else if (element.contextTagNum() == I_PV6_ADDRESSES_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          IPv6Addresses = castingValue.map((elementcastingValue) -> elementcastingValue.value(byte[].class));
+        }
+      } else if (element.contextTagNum() == TYPE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          type = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new GeneralDiagnosticsClusterNetworkInterface(
+      name,
+      isOperational,
+      offPremiseServicesReachableIPv4,
+      offPremiseServicesReachableIPv6,
+      hardwareAddress,
+      IPv4Addresses,
+      IPv6Addresses,
+      type
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -745,6 +1791,12 @@ public static class SoftwareDiagnosticsClusterThreadMetricsStruct {
   public Optional<Long> stackFreeCurrent;
   public Optional<Long> stackFreeMinimum;
   public Optional<Long> stackSize;
+  private static final long ID_ID = 0L;
+  private static final long NAME_ID = 1L;
+  private static final long STACK_FREE_CURRENT_ID = 2L;
+  private static final long STACK_FREE_MINIMUM_ID = 3L;
+  private static final long STACK_SIZE_ID = 4L;
+
   public SoftwareDiagnosticsClusterThreadMetricsStruct(
     Long id,
     Optional<String> name,
@@ -759,6 +1811,63 @@ public SoftwareDiagnosticsClusterThreadMetricsStruct(
     this.stackSize = stackSize;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ID_ID, new UIntType(id)));
+    values.add(new StructElement(NAME_ID, name.<BaseTLVType>map((nonOptionalname) -> new StringType(nonOptionalname)).orElse(new EmptyType())));
+    values.add(new StructElement(STACK_FREE_CURRENT_ID, stackFreeCurrent.<BaseTLVType>map((nonOptionalstackFreeCurrent) -> new UIntType(nonOptionalstackFreeCurrent)).orElse(new EmptyType())));
+    values.add(new StructElement(STACK_FREE_MINIMUM_ID, stackFreeMinimum.<BaseTLVType>map((nonOptionalstackFreeMinimum) -> new UIntType(nonOptionalstackFreeMinimum)).orElse(new EmptyType())));
+    values.add(new StructElement(STACK_SIZE_ID, stackSize.<BaseTLVType>map((nonOptionalstackSize) -> new UIntType(nonOptionalstackSize)).orElse(new EmptyType())));
+
+    return new StructType(values);
+  }
+
+  public static SoftwareDiagnosticsClusterThreadMetricsStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Long id = null;
+    Optional<String> name = Optional.empty();
+    Optional<Long> stackFreeCurrent = Optional.empty();
+    Optional<Long> stackFreeMinimum = Optional.empty();
+    Optional<Long> stackSize = Optional.empty();
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ID_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          id = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == NAME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          name = Optional.of(castingValue.value(String.class));
+        }
+      } else if (element.contextTagNum() == STACK_FREE_CURRENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          stackFreeCurrent = Optional.of(castingValue.value(Long.class));
+        }
+      } else if (element.contextTagNum() == STACK_FREE_MINIMUM_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          stackFreeMinimum = Optional.of(castingValue.value(Long.class));
+        }
+      } else if (element.contextTagNum() == STACK_SIZE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          stackSize = Optional.of(castingValue.value(Long.class));
+        }
+      }
+    }
+    return new SoftwareDiagnosticsClusterThreadMetricsStruct(
+      id,
+      name,
+      stackFreeCurrent,
+      stackFreeMinimum,
+      stackSize
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -797,6 +1906,21 @@ public static class ThreadNetworkDiagnosticsClusterNeighborTableStruct {
   public Boolean fullThreadDevice;
   public Boolean fullNetworkData;
   public Boolean isChild;
+  private static final long EXT_ADDRESS_ID = 0L;
+  private static final long AGE_ID = 1L;
+  private static final long RLOC16_ID = 2L;
+  private static final long LINK_FRAME_COUNTER_ID = 3L;
+  private static final long MLE_FRAME_COUNTER_ID = 4L;
+  private static final long LQI_ID = 5L;
+  private static final long AVERAGE_RSSI_ID = 6L;
+  private static final long LAST_RSSI_ID = 7L;
+  private static final long FRAME_ERROR_RATE_ID = 8L;
+  private static final long MESSAGE_ERROR_RATE_ID = 9L;
+  private static final long RX_ON_WHEN_IDLE_ID = 10L;
+  private static final long FULL_THREAD_DEVICE_ID = 11L;
+  private static final long FULL_NETWORK_DATA_ID = 12L;
+  private static final long IS_CHILD_ID = 13L;
+
   public ThreadNetworkDiagnosticsClusterNeighborTableStruct(
     Long extAddress,
     Long age,
@@ -829,6 +1953,135 @@ public ThreadNetworkDiagnosticsClusterNeighborTableStruct(
     this.isChild = isChild;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(EXT_ADDRESS_ID, new UIntType(extAddress)));
+    values.add(new StructElement(AGE_ID, new UIntType(age)));
+    values.add(new StructElement(RLOC16_ID, new UIntType(rloc16)));
+    values.add(new StructElement(LINK_FRAME_COUNTER_ID, new UIntType(linkFrameCounter)));
+    values.add(new StructElement(MLE_FRAME_COUNTER_ID, new UIntType(mleFrameCounter)));
+    values.add(new StructElement(LQI_ID, new UIntType(lqi)));
+    values.add(new StructElement(AVERAGE_RSSI_ID, averageRssi != null ? new IntType(averageRssi) : new NullType()));
+    values.add(new StructElement(LAST_RSSI_ID, lastRssi != null ? new IntType(lastRssi) : new NullType()));
+    values.add(new StructElement(FRAME_ERROR_RATE_ID, new UIntType(frameErrorRate)));
+    values.add(new StructElement(MESSAGE_ERROR_RATE_ID, new UIntType(messageErrorRate)));
+    values.add(new StructElement(RX_ON_WHEN_IDLE_ID, new BooleanType(rxOnWhenIdle)));
+    values.add(new StructElement(FULL_THREAD_DEVICE_ID, new BooleanType(fullThreadDevice)));
+    values.add(new StructElement(FULL_NETWORK_DATA_ID, new BooleanType(fullNetworkData)));
+    values.add(new StructElement(IS_CHILD_ID, new BooleanType(isChild)));
+
+    return new StructType(values);
+  }
+
+  public static ThreadNetworkDiagnosticsClusterNeighborTableStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Long extAddress = null;
+    Long age = null;
+    Integer rloc16 = null;
+    Long linkFrameCounter = null;
+    Long mleFrameCounter = null;
+    Integer lqi = null;
+    @Nullable Integer averageRssi = null;
+    @Nullable Integer lastRssi = null;
+    Integer frameErrorRate = null;
+    Integer messageErrorRate = null;
+    Boolean rxOnWhenIdle = null;
+    Boolean fullThreadDevice = null;
+    Boolean fullNetworkData = null;
+    Boolean isChild = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == EXT_ADDRESS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          extAddress = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == AGE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          age = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == RLOC16_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          rloc16 = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == LINK_FRAME_COUNTER_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          linkFrameCounter = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == MLE_FRAME_COUNTER_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          mleFrameCounter = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == LQI_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          lqi = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == AVERAGE_RSSI_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Int) {
+          IntType castingValue = element.value(IntType.class);
+          averageRssi = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == LAST_RSSI_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Int) {
+          IntType castingValue = element.value(IntType.class);
+          lastRssi = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == FRAME_ERROR_RATE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          frameErrorRate = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == MESSAGE_ERROR_RATE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          messageErrorRate = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == RX_ON_WHEN_IDLE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          rxOnWhenIdle = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == FULL_THREAD_DEVICE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          fullThreadDevice = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == FULL_NETWORK_DATA_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          fullNetworkData = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == IS_CHILD_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          isChild = castingValue.value(Boolean.class);
+        }
+      }
+    }
+    return new ThreadNetworkDiagnosticsClusterNeighborTableStruct(
+      extAddress,
+      age,
+      rloc16,
+      linkFrameCounter,
+      mleFrameCounter,
+      lqi,
+      averageRssi,
+      lastRssi,
+      frameErrorRate,
+      messageErrorRate,
+      rxOnWhenIdle,
+      fullThreadDevice,
+      fullNetworkData,
+      isChild
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -892,6 +2145,19 @@ public static class ThreadNetworkDiagnosticsClusterOperationalDatasetComponents
   public Boolean pskcPresent;
   public Boolean securityPolicyPresent;
   public Boolean channelMaskPresent;
+  private static final long ACTIVE_TIMESTAMP_PRESENT_ID = 0L;
+  private static final long PENDING_TIMESTAMP_PRESENT_ID = 1L;
+  private static final long MASTER_KEY_PRESENT_ID = 2L;
+  private static final long NETWORK_NAME_PRESENT_ID = 3L;
+  private static final long EXTENDED_PAN_ID_PRESENT_ID = 4L;
+  private static final long MESH_LOCAL_PREFIX_PRESENT_ID = 5L;
+  private static final long DELAY_PRESENT_ID = 6L;
+  private static final long PAN_ID_PRESENT_ID = 7L;
+  private static final long CHANNEL_PRESENT_ID = 8L;
+  private static final long PSKC_PRESENT_ID = 9L;
+  private static final long SECURITY_POLICY_PRESENT_ID = 10L;
+  private static final long CHANNEL_MASK_PRESENT_ID = 11L;
+
   public ThreadNetworkDiagnosticsClusterOperationalDatasetComponents(
     Boolean activeTimestampPresent,
     Boolean pendingTimestampPresent,
@@ -920,6 +2186,119 @@ public ThreadNetworkDiagnosticsClusterOperationalDatasetComponents(
     this.channelMaskPresent = channelMaskPresent;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ACTIVE_TIMESTAMP_PRESENT_ID, new BooleanType(activeTimestampPresent)));
+    values.add(new StructElement(PENDING_TIMESTAMP_PRESENT_ID, new BooleanType(pendingTimestampPresent)));
+    values.add(new StructElement(MASTER_KEY_PRESENT_ID, new BooleanType(masterKeyPresent)));
+    values.add(new StructElement(NETWORK_NAME_PRESENT_ID, new BooleanType(networkNamePresent)));
+    values.add(new StructElement(EXTENDED_PAN_ID_PRESENT_ID, new BooleanType(extendedPanIdPresent)));
+    values.add(new StructElement(MESH_LOCAL_PREFIX_PRESENT_ID, new BooleanType(meshLocalPrefixPresent)));
+    values.add(new StructElement(DELAY_PRESENT_ID, new BooleanType(delayPresent)));
+    values.add(new StructElement(PAN_ID_PRESENT_ID, new BooleanType(panIdPresent)));
+    values.add(new StructElement(CHANNEL_PRESENT_ID, new BooleanType(channelPresent)));
+    values.add(new StructElement(PSKC_PRESENT_ID, new BooleanType(pskcPresent)));
+    values.add(new StructElement(SECURITY_POLICY_PRESENT_ID, new BooleanType(securityPolicyPresent)));
+    values.add(new StructElement(CHANNEL_MASK_PRESENT_ID, new BooleanType(channelMaskPresent)));
+
+    return new StructType(values);
+  }
+
+  public static ThreadNetworkDiagnosticsClusterOperationalDatasetComponents decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Boolean activeTimestampPresent = null;
+    Boolean pendingTimestampPresent = null;
+    Boolean masterKeyPresent = null;
+    Boolean networkNamePresent = null;
+    Boolean extendedPanIdPresent = null;
+    Boolean meshLocalPrefixPresent = null;
+    Boolean delayPresent = null;
+    Boolean panIdPresent = null;
+    Boolean channelPresent = null;
+    Boolean pskcPresent = null;
+    Boolean securityPolicyPresent = null;
+    Boolean channelMaskPresent = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ACTIVE_TIMESTAMP_PRESENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          activeTimestampPresent = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == PENDING_TIMESTAMP_PRESENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          pendingTimestampPresent = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == MASTER_KEY_PRESENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          masterKeyPresent = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == NETWORK_NAME_PRESENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          networkNamePresent = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == EXTENDED_PAN_ID_PRESENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          extendedPanIdPresent = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == MESH_LOCAL_PREFIX_PRESENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          meshLocalPrefixPresent = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == DELAY_PRESENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          delayPresent = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == PAN_ID_PRESENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          panIdPresent = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == CHANNEL_PRESENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          channelPresent = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == PSKC_PRESENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          pskcPresent = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == SECURITY_POLICY_PRESENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          securityPolicyPresent = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == CHANNEL_MASK_PRESENT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          channelMaskPresent = castingValue.value(Boolean.class);
+        }
+      }
+    }
+    return new ThreadNetworkDiagnosticsClusterOperationalDatasetComponents(
+      activeTimestampPresent,
+      pendingTimestampPresent,
+      masterKeyPresent,
+      networkNamePresent,
+      extendedPanIdPresent,
+      meshLocalPrefixPresent,
+      delayPresent,
+      panIdPresent,
+      channelPresent,
+      pskcPresent,
+      securityPolicyPresent,
+      channelMaskPresent
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -975,6 +2354,17 @@ public static class ThreadNetworkDiagnosticsClusterRouteTableStruct {
   public Integer age;
   public Boolean allocated;
   public Boolean linkEstablished;
+  private static final long EXT_ADDRESS_ID = 0L;
+  private static final long RLOC16_ID = 1L;
+  private static final long ROUTER_ID_ID = 2L;
+  private static final long NEXT_HOP_ID = 3L;
+  private static final long PATH_COST_ID = 4L;
+  private static final long L_Q_I_IN_ID = 5L;
+  private static final long L_Q_I_OUT_ID = 6L;
+  private static final long AGE_ID = 7L;
+  private static final long ALLOCATED_ID = 8L;
+  private static final long LINK_ESTABLISHED_ID = 9L;
+
   public ThreadNetworkDiagnosticsClusterRouteTableStruct(
     Long extAddress,
     Integer rloc16,
@@ -999,6 +2389,103 @@ public ThreadNetworkDiagnosticsClusterRouteTableStruct(
     this.linkEstablished = linkEstablished;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(EXT_ADDRESS_ID, new UIntType(extAddress)));
+    values.add(new StructElement(RLOC16_ID, new UIntType(rloc16)));
+    values.add(new StructElement(ROUTER_ID_ID, new UIntType(routerId)));
+    values.add(new StructElement(NEXT_HOP_ID, new UIntType(nextHop)));
+    values.add(new StructElement(PATH_COST_ID, new UIntType(pathCost)));
+    values.add(new StructElement(L_Q_I_IN_ID, new UIntType(LQIIn)));
+    values.add(new StructElement(L_Q_I_OUT_ID, new UIntType(LQIOut)));
+    values.add(new StructElement(AGE_ID, new UIntType(age)));
+    values.add(new StructElement(ALLOCATED_ID, new BooleanType(allocated)));
+    values.add(new StructElement(LINK_ESTABLISHED_ID, new BooleanType(linkEstablished)));
+
+    return new StructType(values);
+  }
+
+  public static ThreadNetworkDiagnosticsClusterRouteTableStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Long extAddress = null;
+    Integer rloc16 = null;
+    Integer routerId = null;
+    Integer nextHop = null;
+    Integer pathCost = null;
+    Integer LQIIn = null;
+    Integer LQIOut = null;
+    Integer age = null;
+    Boolean allocated = null;
+    Boolean linkEstablished = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == EXT_ADDRESS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          extAddress = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == RLOC16_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          rloc16 = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == ROUTER_ID_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          routerId = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == NEXT_HOP_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          nextHop = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == PATH_COST_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          pathCost = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == L_Q_I_IN_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          LQIIn = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == L_Q_I_OUT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          LQIOut = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == AGE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          age = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == ALLOCATED_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          allocated = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == LINK_ESTABLISHED_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          linkEstablished = castingValue.value(Boolean.class);
+        }
+      }
+    }
+    return new ThreadNetworkDiagnosticsClusterRouteTableStruct(
+      extAddress,
+      rloc16,
+      routerId,
+      nextHop,
+      pathCost,
+      LQIIn,
+      LQIOut,
+      age,
+      allocated,
+      linkEstablished
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1040,6 +2527,9 @@ public String toString() {
 public static class ThreadNetworkDiagnosticsClusterSecurityPolicy {
   public Integer rotationTime;
   public Integer flags;
+  private static final long ROTATION_TIME_ID = 0L;
+  private static final long FLAGS_ID = 1L;
+
   public ThreadNetworkDiagnosticsClusterSecurityPolicy(
     Integer rotationTime,
     Integer flags
@@ -1048,6 +2538,39 @@ public ThreadNetworkDiagnosticsClusterSecurityPolicy(
     this.flags = flags;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ROTATION_TIME_ID, new UIntType(rotationTime)));
+    values.add(new StructElement(FLAGS_ID, new UIntType(flags)));
+
+    return new StructType(values);
+  }
+
+  public static ThreadNetworkDiagnosticsClusterSecurityPolicy decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer rotationTime = null;
+    Integer flags = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ROTATION_TIME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          rotationTime = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == FLAGS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          flags = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new ThreadNetworkDiagnosticsClusterSecurityPolicy(
+      rotationTime,
+      flags
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1066,6 +2589,10 @@ public static class TimeSynchronizationClusterDSTOffsetStruct {
   public Long offset;
   public Long validStarting;
   public @Nullable Long validUntil;
+  private static final long OFFSET_ID = 0L;
+  private static final long VALID_STARTING_ID = 1L;
+  private static final long VALID_UNTIL_ID = 2L;
+
   public TimeSynchronizationClusterDSTOffsetStruct(
     Long offset,
     Long validStarting,
@@ -1076,6 +2603,47 @@ public TimeSynchronizationClusterDSTOffsetStruct(
     this.validUntil = validUntil;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(OFFSET_ID, new IntType(offset)));
+    values.add(new StructElement(VALID_STARTING_ID, new UIntType(validStarting)));
+    values.add(new StructElement(VALID_UNTIL_ID, validUntil != null ? new UIntType(validUntil) : new NullType()));
+
+    return new StructType(values);
+  }
+
+  public static TimeSynchronizationClusterDSTOffsetStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Long offset = null;
+    Long validStarting = null;
+    @Nullable Long validUntil = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == OFFSET_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Int) {
+          IntType castingValue = element.value(IntType.class);
+          offset = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == VALID_STARTING_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          validStarting = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == VALID_UNTIL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          validUntil = castingValue.value(Long.class);
+        }
+      }
+    }
+    return new TimeSynchronizationClusterDSTOffsetStruct(
+      offset,
+      validStarting,
+      validUntil
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1096,6 +2664,9 @@ public String toString() {
 public static class TimeSynchronizationClusterFabricScopedTrustedTimeSourceStruct {
   public Long nodeID;
   public Integer endpoint;
+  private static final long NODE_I_D_ID = 0L;
+  private static final long ENDPOINT_ID = 1L;
+
   public TimeSynchronizationClusterFabricScopedTrustedTimeSourceStruct(
     Long nodeID,
     Integer endpoint
@@ -1104,6 +2675,39 @@ public TimeSynchronizationClusterFabricScopedTrustedTimeSourceStruct(
     this.endpoint = endpoint;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(NODE_I_D_ID, new UIntType(nodeID)));
+    values.add(new StructElement(ENDPOINT_ID, new UIntType(endpoint)));
+
+    return new StructType(values);
+  }
+
+  public static TimeSynchronizationClusterFabricScopedTrustedTimeSourceStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Long nodeID = null;
+    Integer endpoint = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == NODE_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          nodeID = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == ENDPOINT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          endpoint = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new TimeSynchronizationClusterFabricScopedTrustedTimeSourceStruct(
+      nodeID,
+      endpoint
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1122,6 +2726,10 @@ public static class TimeSynchronizationClusterTimeZoneStruct {
   public Long offset;
   public Long validAt;
   public Optional<String> name;
+  private static final long OFFSET_ID = 0L;
+  private static final long VALID_AT_ID = 1L;
+  private static final long NAME_ID = 2L;
+
   public TimeSynchronizationClusterTimeZoneStruct(
     Long offset,
     Long validAt,
@@ -1132,6 +2740,47 @@ public TimeSynchronizationClusterTimeZoneStruct(
     this.name = name;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(OFFSET_ID, new IntType(offset)));
+    values.add(new StructElement(VALID_AT_ID, new UIntType(validAt)));
+    values.add(new StructElement(NAME_ID, name.<BaseTLVType>map((nonOptionalname) -> new StringType(nonOptionalname)).orElse(new EmptyType())));
+
+    return new StructType(values);
+  }
+
+  public static TimeSynchronizationClusterTimeZoneStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Long offset = null;
+    Long validAt = null;
+    Optional<String> name = Optional.empty();
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == OFFSET_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Int) {
+          IntType castingValue = element.value(IntType.class);
+          offset = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == VALID_AT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          validAt = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == NAME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          name = Optional.of(castingValue.value(String.class));
+        }
+      }
+    }
+    return new TimeSynchronizationClusterTimeZoneStruct(
+      offset,
+      validAt,
+      name
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1153,6 +2802,10 @@ public static class TimeSynchronizationClusterTrustedTimeSourceStruct {
   public Integer fabricIndex;
   public Long nodeID;
   public Integer endpoint;
+  private static final long FABRIC_INDEX_ID = 0L;
+  private static final long NODE_I_D_ID = 1L;
+  private static final long ENDPOINT_ID = 2L;
+
   public TimeSynchronizationClusterTrustedTimeSourceStruct(
     Integer fabricIndex,
     Long nodeID,
@@ -1163,6 +2816,47 @@ public TimeSynchronizationClusterTrustedTimeSourceStruct(
     this.endpoint = endpoint;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(FABRIC_INDEX_ID, new UIntType(fabricIndex)));
+    values.add(new StructElement(NODE_I_D_ID, new UIntType(nodeID)));
+    values.add(new StructElement(ENDPOINT_ID, new UIntType(endpoint)));
+
+    return new StructType(values);
+  }
+
+  public static TimeSynchronizationClusterTrustedTimeSourceStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer fabricIndex = null;
+    Long nodeID = null;
+    Integer endpoint = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == FABRIC_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricIndex = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == NODE_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          nodeID = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == ENDPOINT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          endpoint = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new TimeSynchronizationClusterTrustedTimeSourceStruct(
+      fabricIndex,
+      nodeID,
+      endpoint
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1183,6 +2877,9 @@ public String toString() {
 public static class BridgedDeviceBasicInformationClusterProductAppearanceStruct {
   public Integer finish;
   public @Nullable Integer primaryColor;
+  private static final long FINISH_ID = 0L;
+  private static final long PRIMARY_COLOR_ID = 1L;
+
   public BridgedDeviceBasicInformationClusterProductAppearanceStruct(
     Integer finish,
     @Nullable Integer primaryColor
@@ -1191,6 +2888,39 @@ public BridgedDeviceBasicInformationClusterProductAppearanceStruct(
     this.primaryColor = primaryColor;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(FINISH_ID, new UIntType(finish)));
+    values.add(new StructElement(PRIMARY_COLOR_ID, primaryColor != null ? new UIntType(primaryColor) : new NullType()));
+
+    return new StructType(values);
+  }
+
+  public static BridgedDeviceBasicInformationClusterProductAppearanceStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer finish = null;
+    @Nullable Integer primaryColor = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == FINISH_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          finish = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == PRIMARY_COLOR_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          primaryColor = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new BridgedDeviceBasicInformationClusterProductAppearanceStruct(
+      finish,
+      primaryColor
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1212,6 +2942,13 @@ public static class OperationalCredentialsClusterFabricDescriptorStruct {
   public Long nodeID;
   public String label;
   public Integer fabricIndex;
+  private static final long ROOT_PUBLIC_KEY_ID = 1L;
+  private static final long VENDOR_I_D_ID = 2L;
+  private static final long FABRIC_I_D_ID = 3L;
+  private static final long NODE_I_D_ID = 4L;
+  private static final long LABEL_ID = 5L;
+  private static final long FABRIC_INDEX_ID = 254L;
+
   public OperationalCredentialsClusterFabricDescriptorStruct(
     byte[] rootPublicKey,
     Integer vendorID,
@@ -1228,6 +2965,71 @@ public OperationalCredentialsClusterFabricDescriptorStruct(
     this.fabricIndex = fabricIndex;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ROOT_PUBLIC_KEY_ID, new ByteArrayType(rootPublicKey)));
+    values.add(new StructElement(VENDOR_I_D_ID, new UIntType(vendorID)));
+    values.add(new StructElement(FABRIC_I_D_ID, new UIntType(fabricID)));
+    values.add(new StructElement(NODE_I_D_ID, new UIntType(nodeID)));
+    values.add(new StructElement(LABEL_ID, new StringType(label)));
+    values.add(new StructElement(FABRIC_INDEX_ID, new UIntType(fabricIndex)));
+
+    return new StructType(values);
+  }
+
+  public static OperationalCredentialsClusterFabricDescriptorStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    byte[] rootPublicKey = null;
+    Integer vendorID = null;
+    Long fabricID = null;
+    Long nodeID = null;
+    String label = null;
+    Integer fabricIndex = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ROOT_PUBLIC_KEY_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+          ByteArrayType castingValue = element.value(ByteArrayType.class);
+          rootPublicKey = castingValue.value(byte[].class);
+        }
+      } else if (element.contextTagNum() == VENDOR_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          vendorID = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == FABRIC_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricID = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == NODE_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          nodeID = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == LABEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          label = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == FABRIC_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricIndex = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new OperationalCredentialsClusterFabricDescriptorStruct(
+      rootPublicKey,
+      vendorID,
+      fabricID,
+      nodeID,
+      label,
+      fabricIndex
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1258,6 +3060,10 @@ public static class OperationalCredentialsClusterNOCStruct {
   public byte[] noc;
   public @Nullable byte[] icac;
   public Integer fabricIndex;
+  private static final long NOC_ID = 1L;
+  private static final long ICAC_ID = 2L;
+  private static final long FABRIC_INDEX_ID = 254L;
+
   public OperationalCredentialsClusterNOCStruct(
     byte[] noc,
     @Nullable byte[] icac,
@@ -1268,6 +3074,47 @@ public OperationalCredentialsClusterNOCStruct(
     this.fabricIndex = fabricIndex;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(NOC_ID, new ByteArrayType(noc)));
+    values.add(new StructElement(ICAC_ID, icac != null ? new ByteArrayType(icac) : new NullType()));
+    values.add(new StructElement(FABRIC_INDEX_ID, new UIntType(fabricIndex)));
+
+    return new StructType(values);
+  }
+
+  public static OperationalCredentialsClusterNOCStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    byte[] noc = null;
+    @Nullable byte[] icac = null;
+    Integer fabricIndex = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == NOC_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+          ByteArrayType castingValue = element.value(ByteArrayType.class);
+          noc = castingValue.value(byte[].class);
+        }
+      } else if (element.contextTagNum() == ICAC_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+          ByteArrayType castingValue = element.value(ByteArrayType.class);
+          icac = castingValue.value(byte[].class);
+        }
+      } else if (element.contextTagNum() == FABRIC_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricIndex = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new OperationalCredentialsClusterNOCStruct(
+      noc,
+      icac,
+      fabricIndex
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1290,6 +3137,11 @@ public static class GroupKeyManagementClusterGroupInfoMapStruct {
   public ArrayList<Integer> endpoints;
   public Optional<String> groupName;
   public Integer fabricIndex;
+  private static final long GROUP_ID_ID = 1L;
+  private static final long ENDPOINTS_ID = 2L;
+  private static final long GROUP_NAME_ID = 3L;
+  private static final long FABRIC_INDEX_ID = 254L;
+
   public GroupKeyManagementClusterGroupInfoMapStruct(
     Integer groupId,
     ArrayList<Integer> endpoints,
@@ -1302,6 +3154,55 @@ public GroupKeyManagementClusterGroupInfoMapStruct(
     this.fabricIndex = fabricIndex;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(GROUP_ID_ID, new UIntType(groupId)));
+    values.add(new StructElement(ENDPOINTS_ID, ArrayType.generateArrayType(endpoints, (elementendpoints) -> new UIntType(elementendpoints))));
+    values.add(new StructElement(GROUP_NAME_ID, groupName.<BaseTLVType>map((nonOptionalgroupName) -> new StringType(nonOptionalgroupName)).orElse(new EmptyType())));
+    values.add(new StructElement(FABRIC_INDEX_ID, new UIntType(fabricIndex)));
+
+    return new StructType(values);
+  }
+
+  public static GroupKeyManagementClusterGroupInfoMapStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer groupId = null;
+    ArrayList<Integer> endpoints = null;
+    Optional<String> groupName = Optional.empty();
+    Integer fabricIndex = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == GROUP_ID_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          groupId = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == ENDPOINTS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          endpoints = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == GROUP_NAME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          groupName = Optional.of(castingValue.value(String.class));
+        }
+      } else if (element.contextTagNum() == FABRIC_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricIndex = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new GroupKeyManagementClusterGroupInfoMapStruct(
+      groupId,
+      endpoints,
+      groupName,
+      fabricIndex
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1326,6 +3227,10 @@ public static class GroupKeyManagementClusterGroupKeyMapStruct {
   public Integer groupId;
   public Integer groupKeySetID;
   public Integer fabricIndex;
+  private static final long GROUP_ID_ID = 1L;
+  private static final long GROUP_KEY_SET_I_D_ID = 2L;
+  private static final long FABRIC_INDEX_ID = 254L;
+
   public GroupKeyManagementClusterGroupKeyMapStruct(
     Integer groupId,
     Integer groupKeySetID,
@@ -1336,6 +3241,47 @@ public GroupKeyManagementClusterGroupKeyMapStruct(
     this.fabricIndex = fabricIndex;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(GROUP_ID_ID, new UIntType(groupId)));
+    values.add(new StructElement(GROUP_KEY_SET_I_D_ID, new UIntType(groupKeySetID)));
+    values.add(new StructElement(FABRIC_INDEX_ID, new UIntType(fabricIndex)));
+
+    return new StructType(values);
+  }
+
+  public static GroupKeyManagementClusterGroupKeyMapStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer groupId = null;
+    Integer groupKeySetID = null;
+    Integer fabricIndex = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == GROUP_ID_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          groupId = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == GROUP_KEY_SET_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          groupKeySetID = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == FABRIC_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricIndex = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new GroupKeyManagementClusterGroupKeyMapStruct(
+      groupId,
+      groupKeySetID,
+      fabricIndex
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1362,6 +3308,15 @@ public static class GroupKeyManagementClusterGroupKeySetStruct {
   public @Nullable Long epochStartTime1;
   public @Nullable byte[] epochKey2;
   public @Nullable Long epochStartTime2;
+  private static final long GROUP_KEY_SET_I_D_ID = 0L;
+  private static final long GROUP_KEY_SECURITY_POLICY_ID = 1L;
+  private static final long EPOCH_KEY0_ID = 2L;
+  private static final long EPOCH_START_TIME0_ID = 3L;
+  private static final long EPOCH_KEY1_ID = 4L;
+  private static final long EPOCH_START_TIME1_ID = 5L;
+  private static final long EPOCH_KEY2_ID = 6L;
+  private static final long EPOCH_START_TIME2_ID = 7L;
+
   public GroupKeyManagementClusterGroupKeySetStruct(
     Integer groupKeySetID,
     Integer groupKeySecurityPolicy,
@@ -1382,6 +3337,87 @@ public GroupKeyManagementClusterGroupKeySetStruct(
     this.epochStartTime2 = epochStartTime2;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(GROUP_KEY_SET_I_D_ID, new UIntType(groupKeySetID)));
+    values.add(new StructElement(GROUP_KEY_SECURITY_POLICY_ID, new UIntType(groupKeySecurityPolicy)));
+    values.add(new StructElement(EPOCH_KEY0_ID, epochKey0 != null ? new ByteArrayType(epochKey0) : new NullType()));
+    values.add(new StructElement(EPOCH_START_TIME0_ID, epochStartTime0 != null ? new UIntType(epochStartTime0) : new NullType()));
+    values.add(new StructElement(EPOCH_KEY1_ID, epochKey1 != null ? new ByteArrayType(epochKey1) : new NullType()));
+    values.add(new StructElement(EPOCH_START_TIME1_ID, epochStartTime1 != null ? new UIntType(epochStartTime1) : new NullType()));
+    values.add(new StructElement(EPOCH_KEY2_ID, epochKey2 != null ? new ByteArrayType(epochKey2) : new NullType()));
+    values.add(new StructElement(EPOCH_START_TIME2_ID, epochStartTime2 != null ? new UIntType(epochStartTime2) : new NullType()));
+
+    return new StructType(values);
+  }
+
+  public static GroupKeyManagementClusterGroupKeySetStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer groupKeySetID = null;
+    Integer groupKeySecurityPolicy = null;
+    @Nullable byte[] epochKey0 = null;
+    @Nullable Long epochStartTime0 = null;
+    @Nullable byte[] epochKey1 = null;
+    @Nullable Long epochStartTime1 = null;
+    @Nullable byte[] epochKey2 = null;
+    @Nullable Long epochStartTime2 = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == GROUP_KEY_SET_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          groupKeySetID = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == GROUP_KEY_SECURITY_POLICY_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          groupKeySecurityPolicy = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == EPOCH_KEY0_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+          ByteArrayType castingValue = element.value(ByteArrayType.class);
+          epochKey0 = castingValue.value(byte[].class);
+        }
+      } else if (element.contextTagNum() == EPOCH_START_TIME0_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          epochStartTime0 = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == EPOCH_KEY1_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+          ByteArrayType castingValue = element.value(ByteArrayType.class);
+          epochKey1 = castingValue.value(byte[].class);
+        }
+      } else if (element.contextTagNum() == EPOCH_START_TIME1_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          epochStartTime1 = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == EPOCH_KEY2_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+          ByteArrayType castingValue = element.value(ByteArrayType.class);
+          epochKey2 = castingValue.value(byte[].class);
+        }
+      } else if (element.contextTagNum() == EPOCH_START_TIME2_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          epochStartTime2 = castingValue.value(Long.class);
+        }
+      }
+    }
+    return new GroupKeyManagementClusterGroupKeySetStruct(
+      groupKeySetID,
+      groupKeySecurityPolicy,
+      epochKey0,
+      epochStartTime0,
+      epochKey1,
+      epochStartTime1,
+      epochKey2,
+      epochStartTime2
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1417,6 +3453,9 @@ public String toString() {
 public static class FixedLabelClusterLabelStruct {
   public String label;
   public String value;
+  private static final long LABEL_ID = 0L;
+  private static final long VALUE_ID = 1L;
+
   public FixedLabelClusterLabelStruct(
     String label,
     String value
@@ -1425,6 +3464,39 @@ public FixedLabelClusterLabelStruct(
     this.value = value;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(LABEL_ID, new StringType(label)));
+    values.add(new StructElement(VALUE_ID, new StringType(value)));
+
+    return new StructType(values);
+  }
+
+  public static FixedLabelClusterLabelStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    String label = null;
+    String value = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == LABEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          label = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == VALUE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          value = castingValue.value(String.class);
+        }
+      }
+    }
+    return new FixedLabelClusterLabelStruct(
+      label,
+      value
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1442,6 +3514,9 @@ public String toString() {
 public static class UserLabelClusterLabelStruct {
   public String label;
   public String value;
+  private static final long LABEL_ID = 0L;
+  private static final long VALUE_ID = 1L;
+
   public UserLabelClusterLabelStruct(
     String label,
     String value
@@ -1450,6 +3525,39 @@ public UserLabelClusterLabelStruct(
     this.value = value;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(LABEL_ID, new StringType(label)));
+    values.add(new StructElement(VALUE_ID, new StringType(value)));
+
+    return new StructType(values);
+  }
+
+  public static UserLabelClusterLabelStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    String label = null;
+    String value = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == LABEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          label = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == VALUE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          value = castingValue.value(String.class);
+        }
+      }
+    }
+    return new UserLabelClusterLabelStruct(
+      label,
+      value
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1468,6 +3576,10 @@ public static class IcdManagementClusterMonitoringRegistrationStruct {
   public Long checkInNodeID;
   public Long monitoredSubject;
   public Integer fabricIndex;
+  private static final long CHECK_IN_NODE_I_D_ID = 1L;
+  private static final long MONITORED_SUBJECT_ID = 2L;
+  private static final long FABRIC_INDEX_ID = 254L;
+
   public IcdManagementClusterMonitoringRegistrationStruct(
     Long checkInNodeID,
     Long monitoredSubject,
@@ -1478,6 +3590,47 @@ public IcdManagementClusterMonitoringRegistrationStruct(
     this.fabricIndex = fabricIndex;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(CHECK_IN_NODE_I_D_ID, new UIntType(checkInNodeID)));
+    values.add(new StructElement(MONITORED_SUBJECT_ID, new UIntType(monitoredSubject)));
+    values.add(new StructElement(FABRIC_INDEX_ID, new UIntType(fabricIndex)));
+
+    return new StructType(values);
+  }
+
+  public static IcdManagementClusterMonitoringRegistrationStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Long checkInNodeID = null;
+    Long monitoredSubject = null;
+    Integer fabricIndex = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == CHECK_IN_NODE_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          checkInNodeID = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == MONITORED_SUBJECT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          monitoredSubject = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == FABRIC_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricIndex = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new IcdManagementClusterMonitoringRegistrationStruct(
+      checkInNodeID,
+      monitoredSubject,
+      fabricIndex
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1498,6 +3651,9 @@ public String toString() {
 public static class ModeSelectClusterSemanticTagStruct {
   public Integer mfgCode;
   public Integer value;
+  private static final long MFG_CODE_ID = 0L;
+  private static final long VALUE_ID = 1L;
+
   public ModeSelectClusterSemanticTagStruct(
     Integer mfgCode,
     Integer value
@@ -1506,6 +3662,39 @@ public ModeSelectClusterSemanticTagStruct(
     this.value = value;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(MFG_CODE_ID, new UIntType(mfgCode)));
+    values.add(new StructElement(VALUE_ID, new UIntType(value)));
+
+    return new StructType(values);
+  }
+
+  public static ModeSelectClusterSemanticTagStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer mfgCode = null;
+    Integer value = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == MFG_CODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          mfgCode = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == VALUE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          value = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new ModeSelectClusterSemanticTagStruct(
+      mfgCode,
+      value
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1524,6 +3713,10 @@ public static class ModeSelectClusterModeOptionStruct {
   public String label;
   public Integer mode;
   public ArrayList<ChipStructs.ModeSelectClusterSemanticTagStruct> semanticTags;
+  private static final long LABEL_ID = 0L;
+  private static final long MODE_ID = 1L;
+  private static final long SEMANTIC_TAGS_ID = 2L;
+
   public ModeSelectClusterModeOptionStruct(
     String label,
     Integer mode,
@@ -1534,6 +3727,47 @@ public ModeSelectClusterModeOptionStruct(
     this.semanticTags = semanticTags;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(LABEL_ID, new StringType(label)));
+    values.add(new StructElement(MODE_ID, new UIntType(mode)));
+    values.add(new StructElement(SEMANTIC_TAGS_ID, ArrayType.generateArrayType(semanticTags, (elementsemanticTags) -> elementsemanticTags.encodeTlv())));
+
+    return new StructType(values);
+  }
+
+  public static ModeSelectClusterModeOptionStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    String label = null;
+    Integer mode = null;
+    ArrayList<ChipStructs.ModeSelectClusterSemanticTagStruct> semanticTags = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == LABEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          label = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == MODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          mode = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == SEMANTIC_TAGS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          semanticTags = castingValue.map((elementcastingValue) -> ChipStructs.ModeSelectClusterSemanticTagStruct.decodeTlv(elementcastingValue));
+        }
+      }
+    }
+    return new ModeSelectClusterModeOptionStruct(
+      label,
+      mode,
+      semanticTags
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1554,6 +3788,9 @@ public String toString() {
 public static class LaundryWasherModeClusterModeTagStruct {
   public Optional<Integer> mfgCode;
   public Integer value;
+  private static final long MFG_CODE_ID = 0L;
+  private static final long VALUE_ID = 1L;
+
   public LaundryWasherModeClusterModeTagStruct(
     Optional<Integer> mfgCode,
     Integer value
@@ -1562,6 +3799,39 @@ public LaundryWasherModeClusterModeTagStruct(
     this.value = value;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(MFG_CODE_ID, mfgCode.<BaseTLVType>map((nonOptionalmfgCode) -> new UIntType(nonOptionalmfgCode)).orElse(new EmptyType())));
+    values.add(new StructElement(VALUE_ID, new UIntType(value)));
+
+    return new StructType(values);
+  }
+
+  public static LaundryWasherModeClusterModeTagStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Optional<Integer> mfgCode = Optional.empty();
+    Integer value = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == MFG_CODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          mfgCode = Optional.of(castingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == VALUE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          value = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new LaundryWasherModeClusterModeTagStruct(
+      mfgCode,
+      value
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1580,6 +3850,10 @@ public static class LaundryWasherModeClusterModeOptionStruct {
   public String label;
   public Integer mode;
   public ArrayList<ChipStructs.LaundryWasherModeClusterModeTagStruct> modeTags;
+  private static final long LABEL_ID = 0L;
+  private static final long MODE_ID = 1L;
+  private static final long MODE_TAGS_ID = 2L;
+
   public LaundryWasherModeClusterModeOptionStruct(
     String label,
     Integer mode,
@@ -1590,6 +3864,47 @@ public LaundryWasherModeClusterModeOptionStruct(
     this.modeTags = modeTags;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(LABEL_ID, new StringType(label)));
+    values.add(new StructElement(MODE_ID, new UIntType(mode)));
+    values.add(new StructElement(MODE_TAGS_ID, ArrayType.generateArrayType(modeTags, (elementmodeTags) -> elementmodeTags.encodeTlv())));
+
+    return new StructType(values);
+  }
+
+  public static LaundryWasherModeClusterModeOptionStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    String label = null;
+    Integer mode = null;
+    ArrayList<ChipStructs.LaundryWasherModeClusterModeTagStruct> modeTags = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == LABEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          label = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == MODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          mode = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == MODE_TAGS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          modeTags = castingValue.map((elementcastingValue) -> ChipStructs.LaundryWasherModeClusterModeTagStruct.decodeTlv(elementcastingValue));
+        }
+      }
+    }
+    return new LaundryWasherModeClusterModeOptionStruct(
+      label,
+      mode,
+      modeTags
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1610,6 +3925,9 @@ public String toString() {
 public static class RefrigeratorAndTemperatureControlledCabinetModeClusterModeTagStruct {
   public Optional<Integer> mfgCode;
   public Integer value;
+  private static final long MFG_CODE_ID = 0L;
+  private static final long VALUE_ID = 1L;
+
   public RefrigeratorAndTemperatureControlledCabinetModeClusterModeTagStruct(
     Optional<Integer> mfgCode,
     Integer value
@@ -1618,6 +3936,39 @@ public RefrigeratorAndTemperatureControlledCabinetModeClusterModeTagStruct(
     this.value = value;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(MFG_CODE_ID, mfgCode.<BaseTLVType>map((nonOptionalmfgCode) -> new UIntType(nonOptionalmfgCode)).orElse(new EmptyType())));
+    values.add(new StructElement(VALUE_ID, new UIntType(value)));
+
+    return new StructType(values);
+  }
+
+  public static RefrigeratorAndTemperatureControlledCabinetModeClusterModeTagStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Optional<Integer> mfgCode = Optional.empty();
+    Integer value = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == MFG_CODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          mfgCode = Optional.of(castingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == VALUE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          value = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new RefrigeratorAndTemperatureControlledCabinetModeClusterModeTagStruct(
+      mfgCode,
+      value
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1636,6 +3987,10 @@ public static class RefrigeratorAndTemperatureControlledCabinetModeClusterModeOp
   public String label;
   public Integer mode;
   public ArrayList<ChipStructs.RefrigeratorAndTemperatureControlledCabinetModeClusterModeTagStruct> modeTags;
+  private static final long LABEL_ID = 0L;
+  private static final long MODE_ID = 1L;
+  private static final long MODE_TAGS_ID = 2L;
+
   public RefrigeratorAndTemperatureControlledCabinetModeClusterModeOptionStruct(
     String label,
     Integer mode,
@@ -1646,6 +4001,47 @@ public RefrigeratorAndTemperatureControlledCabinetModeClusterModeOptionStruct(
     this.modeTags = modeTags;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(LABEL_ID, new StringType(label)));
+    values.add(new StructElement(MODE_ID, new UIntType(mode)));
+    values.add(new StructElement(MODE_TAGS_ID, ArrayType.generateArrayType(modeTags, (elementmodeTags) -> elementmodeTags.encodeTlv())));
+
+    return new StructType(values);
+  }
+
+  public static RefrigeratorAndTemperatureControlledCabinetModeClusterModeOptionStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    String label = null;
+    Integer mode = null;
+    ArrayList<ChipStructs.RefrigeratorAndTemperatureControlledCabinetModeClusterModeTagStruct> modeTags = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == LABEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          label = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == MODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          mode = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == MODE_TAGS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          modeTags = castingValue.map((elementcastingValue) -> ChipStructs.RefrigeratorAndTemperatureControlledCabinetModeClusterModeTagStruct.decodeTlv(elementcastingValue));
+        }
+      }
+    }
+    return new RefrigeratorAndTemperatureControlledCabinetModeClusterModeOptionStruct(
+      label,
+      mode,
+      modeTags
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1666,6 +4062,9 @@ public String toString() {
 public static class RvcRunModeClusterModeTagStruct {
   public Optional<Integer> mfgCode;
   public Integer value;
+  private static final long MFG_CODE_ID = 0L;
+  private static final long VALUE_ID = 1L;
+
   public RvcRunModeClusterModeTagStruct(
     Optional<Integer> mfgCode,
     Integer value
@@ -1674,6 +4073,39 @@ public RvcRunModeClusterModeTagStruct(
     this.value = value;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(MFG_CODE_ID, mfgCode.<BaseTLVType>map((nonOptionalmfgCode) -> new UIntType(nonOptionalmfgCode)).orElse(new EmptyType())));
+    values.add(new StructElement(VALUE_ID, new UIntType(value)));
+
+    return new StructType(values);
+  }
+
+  public static RvcRunModeClusterModeTagStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Optional<Integer> mfgCode = Optional.empty();
+    Integer value = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == MFG_CODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          mfgCode = Optional.of(castingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == VALUE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          value = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new RvcRunModeClusterModeTagStruct(
+      mfgCode,
+      value
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1692,6 +4124,10 @@ public static class RvcRunModeClusterModeOptionStruct {
   public String label;
   public Integer mode;
   public ArrayList<ChipStructs.RvcRunModeClusterModeTagStruct> modeTags;
+  private static final long LABEL_ID = 0L;
+  private static final long MODE_ID = 1L;
+  private static final long MODE_TAGS_ID = 2L;
+
   public RvcRunModeClusterModeOptionStruct(
     String label,
     Integer mode,
@@ -1702,6 +4138,47 @@ public RvcRunModeClusterModeOptionStruct(
     this.modeTags = modeTags;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(LABEL_ID, new StringType(label)));
+    values.add(new StructElement(MODE_ID, new UIntType(mode)));
+    values.add(new StructElement(MODE_TAGS_ID, ArrayType.generateArrayType(modeTags, (elementmodeTags) -> elementmodeTags.encodeTlv())));
+
+    return new StructType(values);
+  }
+
+  public static RvcRunModeClusterModeOptionStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    String label = null;
+    Integer mode = null;
+    ArrayList<ChipStructs.RvcRunModeClusterModeTagStruct> modeTags = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == LABEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          label = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == MODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          mode = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == MODE_TAGS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          modeTags = castingValue.map((elementcastingValue) -> ChipStructs.RvcRunModeClusterModeTagStruct.decodeTlv(elementcastingValue));
+        }
+      }
+    }
+    return new RvcRunModeClusterModeOptionStruct(
+      label,
+      mode,
+      modeTags
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1722,6 +4199,9 @@ public String toString() {
 public static class RvcCleanModeClusterModeTagStruct {
   public Optional<Integer> mfgCode;
   public Integer value;
+  private static final long MFG_CODE_ID = 0L;
+  private static final long VALUE_ID = 1L;
+
   public RvcCleanModeClusterModeTagStruct(
     Optional<Integer> mfgCode,
     Integer value
@@ -1730,6 +4210,39 @@ public RvcCleanModeClusterModeTagStruct(
     this.value = value;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(MFG_CODE_ID, mfgCode.<BaseTLVType>map((nonOptionalmfgCode) -> new UIntType(nonOptionalmfgCode)).orElse(new EmptyType())));
+    values.add(new StructElement(VALUE_ID, new UIntType(value)));
+
+    return new StructType(values);
+  }
+
+  public static RvcCleanModeClusterModeTagStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Optional<Integer> mfgCode = Optional.empty();
+    Integer value = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == MFG_CODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          mfgCode = Optional.of(castingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == VALUE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          value = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new RvcCleanModeClusterModeTagStruct(
+      mfgCode,
+      value
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1748,6 +4261,10 @@ public static class RvcCleanModeClusterModeOptionStruct {
   public String label;
   public Integer mode;
   public ArrayList<ChipStructs.RvcCleanModeClusterModeTagStruct> modeTags;
+  private static final long LABEL_ID = 0L;
+  private static final long MODE_ID = 1L;
+  private static final long MODE_TAGS_ID = 2L;
+
   public RvcCleanModeClusterModeOptionStruct(
     String label,
     Integer mode,
@@ -1758,6 +4275,47 @@ public RvcCleanModeClusterModeOptionStruct(
     this.modeTags = modeTags;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(LABEL_ID, new StringType(label)));
+    values.add(new StructElement(MODE_ID, new UIntType(mode)));
+    values.add(new StructElement(MODE_TAGS_ID, ArrayType.generateArrayType(modeTags, (elementmodeTags) -> elementmodeTags.encodeTlv())));
+
+    return new StructType(values);
+  }
+
+  public static RvcCleanModeClusterModeOptionStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    String label = null;
+    Integer mode = null;
+    ArrayList<ChipStructs.RvcCleanModeClusterModeTagStruct> modeTags = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == LABEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          label = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == MODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          mode = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == MODE_TAGS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          modeTags = castingValue.map((elementcastingValue) -> ChipStructs.RvcCleanModeClusterModeTagStruct.decodeTlv(elementcastingValue));
+        }
+      }
+    }
+    return new RvcCleanModeClusterModeOptionStruct(
+      label,
+      mode,
+      modeTags
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1778,6 +4336,9 @@ public String toString() {
 public static class DishwasherModeClusterModeTagStruct {
   public Optional<Integer> mfgCode;
   public Integer value;
+  private static final long MFG_CODE_ID = 0L;
+  private static final long VALUE_ID = 1L;
+
   public DishwasherModeClusterModeTagStruct(
     Optional<Integer> mfgCode,
     Integer value
@@ -1786,6 +4347,39 @@ public DishwasherModeClusterModeTagStruct(
     this.value = value;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(MFG_CODE_ID, mfgCode.<BaseTLVType>map((nonOptionalmfgCode) -> new UIntType(nonOptionalmfgCode)).orElse(new EmptyType())));
+    values.add(new StructElement(VALUE_ID, new UIntType(value)));
+
+    return new StructType(values);
+  }
+
+  public static DishwasherModeClusterModeTagStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Optional<Integer> mfgCode = Optional.empty();
+    Integer value = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == MFG_CODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          mfgCode = Optional.of(castingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == VALUE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          value = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new DishwasherModeClusterModeTagStruct(
+      mfgCode,
+      value
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1804,6 +4398,10 @@ public static class DishwasherModeClusterModeOptionStruct {
   public String label;
   public Integer mode;
   public ArrayList<ChipStructs.DishwasherModeClusterModeTagStruct> modeTags;
+  private static final long LABEL_ID = 0L;
+  private static final long MODE_ID = 1L;
+  private static final long MODE_TAGS_ID = 2L;
+
   public DishwasherModeClusterModeOptionStruct(
     String label,
     Integer mode,
@@ -1814,6 +4412,47 @@ public DishwasherModeClusterModeOptionStruct(
     this.modeTags = modeTags;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(LABEL_ID, new StringType(label)));
+    values.add(new StructElement(MODE_ID, new UIntType(mode)));
+    values.add(new StructElement(MODE_TAGS_ID, ArrayType.generateArrayType(modeTags, (elementmodeTags) -> elementmodeTags.encodeTlv())));
+
+    return new StructType(values);
+  }
+
+  public static DishwasherModeClusterModeOptionStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    String label = null;
+    Integer mode = null;
+    ArrayList<ChipStructs.DishwasherModeClusterModeTagStruct> modeTags = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == LABEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          label = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == MODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          mode = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == MODE_TAGS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          modeTags = castingValue.map((elementcastingValue) -> ChipStructs.DishwasherModeClusterModeTagStruct.decodeTlv(elementcastingValue));
+        }
+      }
+    }
+    return new DishwasherModeClusterModeOptionStruct(
+      label,
+      mode,
+      modeTags
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1834,6 +4473,9 @@ public String toString() {
 public static class MicrowaveOvenModeClusterModeTagStruct {
   public Optional<Integer> mfgCode;
   public Integer value;
+  private static final long MFG_CODE_ID = 0L;
+  private static final long VALUE_ID = 1L;
+
   public MicrowaveOvenModeClusterModeTagStruct(
     Optional<Integer> mfgCode,
     Integer value
@@ -1842,6 +4484,39 @@ public MicrowaveOvenModeClusterModeTagStruct(
     this.value = value;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(MFG_CODE_ID, mfgCode.<BaseTLVType>map((nonOptionalmfgCode) -> new UIntType(nonOptionalmfgCode)).orElse(new EmptyType())));
+    values.add(new StructElement(VALUE_ID, new UIntType(value)));
+
+    return new StructType(values);
+  }
+
+  public static MicrowaveOvenModeClusterModeTagStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Optional<Integer> mfgCode = Optional.empty();
+    Integer value = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == MFG_CODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          mfgCode = Optional.of(castingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == VALUE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          value = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new MicrowaveOvenModeClusterModeTagStruct(
+      mfgCode,
+      value
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1860,6 +4535,10 @@ public static class MicrowaveOvenModeClusterModeOptionStruct {
   public String label;
   public Integer mode;
   public ArrayList<ChipStructs.MicrowaveOvenModeClusterModeTagStruct> modeTags;
+  private static final long LABEL_ID = 0L;
+  private static final long MODE_ID = 1L;
+  private static final long MODE_TAGS_ID = 2L;
+
   public MicrowaveOvenModeClusterModeOptionStruct(
     String label,
     Integer mode,
@@ -1870,6 +4549,47 @@ public MicrowaveOvenModeClusterModeOptionStruct(
     this.modeTags = modeTags;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(LABEL_ID, new StringType(label)));
+    values.add(new StructElement(MODE_ID, new UIntType(mode)));
+    values.add(new StructElement(MODE_TAGS_ID, ArrayType.generateArrayType(modeTags, (elementmodeTags) -> elementmodeTags.encodeTlv())));
+
+    return new StructType(values);
+  }
+
+  public static MicrowaveOvenModeClusterModeOptionStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    String label = null;
+    Integer mode = null;
+    ArrayList<ChipStructs.MicrowaveOvenModeClusterModeTagStruct> modeTags = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == LABEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          label = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == MODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          mode = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == MODE_TAGS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          modeTags = castingValue.map((elementcastingValue) -> ChipStructs.MicrowaveOvenModeClusterModeTagStruct.decodeTlv(elementcastingValue));
+        }
+      }
+    }
+    return new MicrowaveOvenModeClusterModeOptionStruct(
+      label,
+      mode,
+      modeTags
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1891,6 +4611,10 @@ public static class OperationalStateClusterErrorStateStruct {
   public Integer errorStateID;
   public Optional<String> errorStateLabel;
   public Optional<String> errorStateDetails;
+  private static final long ERROR_STATE_I_D_ID = 0L;
+  private static final long ERROR_STATE_LABEL_ID = 1L;
+  private static final long ERROR_STATE_DETAILS_ID = 2L;
+
   public OperationalStateClusterErrorStateStruct(
     Integer errorStateID,
     Optional<String> errorStateLabel,
@@ -1901,6 +4625,47 @@ public OperationalStateClusterErrorStateStruct(
     this.errorStateDetails = errorStateDetails;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ERROR_STATE_I_D_ID, new UIntType(errorStateID)));
+    values.add(new StructElement(ERROR_STATE_LABEL_ID, errorStateLabel.<BaseTLVType>map((nonOptionalerrorStateLabel) -> new StringType(nonOptionalerrorStateLabel)).orElse(new EmptyType())));
+    values.add(new StructElement(ERROR_STATE_DETAILS_ID, errorStateDetails.<BaseTLVType>map((nonOptionalerrorStateDetails) -> new StringType(nonOptionalerrorStateDetails)).orElse(new EmptyType())));
+
+    return new StructType(values);
+  }
+
+  public static OperationalStateClusterErrorStateStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer errorStateID = null;
+    Optional<String> errorStateLabel = Optional.empty();
+    Optional<String> errorStateDetails = Optional.empty();
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ERROR_STATE_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          errorStateID = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == ERROR_STATE_LABEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          errorStateLabel = Optional.of(castingValue.value(String.class));
+        }
+      } else if (element.contextTagNum() == ERROR_STATE_DETAILS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          errorStateDetails = Optional.of(castingValue.value(String.class));
+        }
+      }
+    }
+    return new OperationalStateClusterErrorStateStruct(
+      errorStateID,
+      errorStateLabel,
+      errorStateDetails
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1921,6 +4686,9 @@ public String toString() {
 public static class OperationalStateClusterOperationalStateStruct {
   public Integer operationalStateID;
   public Optional<String> operationalStateLabel;
+  private static final long OPERATIONAL_STATE_I_D_ID = 0L;
+  private static final long OPERATIONAL_STATE_LABEL_ID = 1L;
+
   public OperationalStateClusterOperationalStateStruct(
     Integer operationalStateID,
     Optional<String> operationalStateLabel
@@ -1929,6 +4697,39 @@ public OperationalStateClusterOperationalStateStruct(
     this.operationalStateLabel = operationalStateLabel;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(OPERATIONAL_STATE_I_D_ID, new UIntType(operationalStateID)));
+    values.add(new StructElement(OPERATIONAL_STATE_LABEL_ID, operationalStateLabel.<BaseTLVType>map((nonOptionaloperationalStateLabel) -> new StringType(nonOptionaloperationalStateLabel)).orElse(new EmptyType())));
+
+    return new StructType(values);
+  }
+
+  public static OperationalStateClusterOperationalStateStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer operationalStateID = null;
+    Optional<String> operationalStateLabel = Optional.empty();
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == OPERATIONAL_STATE_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          operationalStateID = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == OPERATIONAL_STATE_LABEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          operationalStateLabel = Optional.of(castingValue.value(String.class));
+        }
+      }
+    }
+    return new OperationalStateClusterOperationalStateStruct(
+      operationalStateID,
+      operationalStateLabel
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1947,6 +4748,10 @@ public static class RvcOperationalStateClusterErrorStateStruct {
   public Integer errorStateID;
   public Optional<String> errorStateLabel;
   public Optional<String> errorStateDetails;
+  private static final long ERROR_STATE_I_D_ID = 0L;
+  private static final long ERROR_STATE_LABEL_ID = 1L;
+  private static final long ERROR_STATE_DETAILS_ID = 2L;
+
   public RvcOperationalStateClusterErrorStateStruct(
     Integer errorStateID,
     Optional<String> errorStateLabel,
@@ -1957,6 +4762,47 @@ public RvcOperationalStateClusterErrorStateStruct(
     this.errorStateDetails = errorStateDetails;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(ERROR_STATE_I_D_ID, new UIntType(errorStateID)));
+    values.add(new StructElement(ERROR_STATE_LABEL_ID, errorStateLabel.<BaseTLVType>map((nonOptionalerrorStateLabel) -> new StringType(nonOptionalerrorStateLabel)).orElse(new EmptyType())));
+    values.add(new StructElement(ERROR_STATE_DETAILS_ID, errorStateDetails.<BaseTLVType>map((nonOptionalerrorStateDetails) -> new StringType(nonOptionalerrorStateDetails)).orElse(new EmptyType())));
+
+    return new StructType(values);
+  }
+
+  public static RvcOperationalStateClusterErrorStateStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer errorStateID = null;
+    Optional<String> errorStateLabel = Optional.empty();
+    Optional<String> errorStateDetails = Optional.empty();
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == ERROR_STATE_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          errorStateID = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == ERROR_STATE_LABEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          errorStateLabel = Optional.of(castingValue.value(String.class));
+        }
+      } else if (element.contextTagNum() == ERROR_STATE_DETAILS_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          errorStateDetails = Optional.of(castingValue.value(String.class));
+        }
+      }
+    }
+    return new RvcOperationalStateClusterErrorStateStruct(
+      errorStateID,
+      errorStateLabel,
+      errorStateDetails
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -1977,6 +4823,9 @@ public String toString() {
 public static class RvcOperationalStateClusterOperationalStateStruct {
   public Integer operationalStateID;
   public Optional<String> operationalStateLabel;
+  private static final long OPERATIONAL_STATE_I_D_ID = 0L;
+  private static final long OPERATIONAL_STATE_LABEL_ID = 1L;
+
   public RvcOperationalStateClusterOperationalStateStruct(
     Integer operationalStateID,
     Optional<String> operationalStateLabel
@@ -1985,6 +4834,39 @@ public RvcOperationalStateClusterOperationalStateStruct(
     this.operationalStateLabel = operationalStateLabel;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(OPERATIONAL_STATE_I_D_ID, new UIntType(operationalStateID)));
+    values.add(new StructElement(OPERATIONAL_STATE_LABEL_ID, operationalStateLabel.<BaseTLVType>map((nonOptionaloperationalStateLabel) -> new StringType(nonOptionaloperationalStateLabel)).orElse(new EmptyType())));
+
+    return new StructType(values);
+  }
+
+  public static RvcOperationalStateClusterOperationalStateStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer operationalStateID = null;
+    Optional<String> operationalStateLabel = Optional.empty();
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == OPERATIONAL_STATE_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          operationalStateID = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == OPERATIONAL_STATE_LABEL_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          operationalStateLabel = Optional.of(castingValue.value(String.class));
+        }
+      }
+    }
+    return new RvcOperationalStateClusterOperationalStateStruct(
+      operationalStateID,
+      operationalStateLabel
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2002,6 +4884,9 @@ public String toString() {
 public static class HepaFilterMonitoringClusterReplacementProductStruct {
   public Integer productIdentifierType;
   public String productIdentifierValue;
+  private static final long PRODUCT_IDENTIFIER_TYPE_ID = 0L;
+  private static final long PRODUCT_IDENTIFIER_VALUE_ID = 1L;
+
   public HepaFilterMonitoringClusterReplacementProductStruct(
     Integer productIdentifierType,
     String productIdentifierValue
@@ -2010,6 +4895,39 @@ public HepaFilterMonitoringClusterReplacementProductStruct(
     this.productIdentifierValue = productIdentifierValue;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(PRODUCT_IDENTIFIER_TYPE_ID, new UIntType(productIdentifierType)));
+    values.add(new StructElement(PRODUCT_IDENTIFIER_VALUE_ID, new StringType(productIdentifierValue)));
+
+    return new StructType(values);
+  }
+
+  public static HepaFilterMonitoringClusterReplacementProductStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer productIdentifierType = null;
+    String productIdentifierValue = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == PRODUCT_IDENTIFIER_TYPE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          productIdentifierType = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == PRODUCT_IDENTIFIER_VALUE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          productIdentifierValue = castingValue.value(String.class);
+        }
+      }
+    }
+    return new HepaFilterMonitoringClusterReplacementProductStruct(
+      productIdentifierType,
+      productIdentifierValue
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2027,6 +4945,9 @@ public String toString() {
 public static class ActivatedCarbonFilterMonitoringClusterReplacementProductStruct {
   public Integer productIdentifierType;
   public String productIdentifierValue;
+  private static final long PRODUCT_IDENTIFIER_TYPE_ID = 0L;
+  private static final long PRODUCT_IDENTIFIER_VALUE_ID = 1L;
+
   public ActivatedCarbonFilterMonitoringClusterReplacementProductStruct(
     Integer productIdentifierType,
     String productIdentifierValue
@@ -2035,6 +4956,39 @@ public ActivatedCarbonFilterMonitoringClusterReplacementProductStruct(
     this.productIdentifierValue = productIdentifierValue;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(PRODUCT_IDENTIFIER_TYPE_ID, new UIntType(productIdentifierType)));
+    values.add(new StructElement(PRODUCT_IDENTIFIER_VALUE_ID, new StringType(productIdentifierValue)));
+
+    return new StructType(values);
+  }
+
+  public static ActivatedCarbonFilterMonitoringClusterReplacementProductStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer productIdentifierType = null;
+    String productIdentifierValue = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == PRODUCT_IDENTIFIER_TYPE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          productIdentifierType = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == PRODUCT_IDENTIFIER_VALUE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          productIdentifierValue = castingValue.value(String.class);
+        }
+      }
+    }
+    return new ActivatedCarbonFilterMonitoringClusterReplacementProductStruct(
+      productIdentifierType,
+      productIdentifierValue
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2052,6 +5006,9 @@ public String toString() {
 public static class DoorLockClusterCredentialStruct {
   public Integer credentialType;
   public Integer credentialIndex;
+  private static final long CREDENTIAL_TYPE_ID = 0L;
+  private static final long CREDENTIAL_INDEX_ID = 1L;
+
   public DoorLockClusterCredentialStruct(
     Integer credentialType,
     Integer credentialIndex
@@ -2060,6 +5017,39 @@ public DoorLockClusterCredentialStruct(
     this.credentialIndex = credentialIndex;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(CREDENTIAL_TYPE_ID, new UIntType(credentialType)));
+    values.add(new StructElement(CREDENTIAL_INDEX_ID, new UIntType(credentialIndex)));
+
+    return new StructType(values);
+  }
+
+  public static DoorLockClusterCredentialStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer credentialType = null;
+    Integer credentialIndex = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == CREDENTIAL_TYPE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          credentialType = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == CREDENTIAL_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          credentialIndex = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new DoorLockClusterCredentialStruct(
+      credentialType,
+      credentialIndex
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2078,6 +5068,10 @@ public static class ThermostatClusterThermostatScheduleTransition {
   public Integer transitionTime;
   public @Nullable Integer heatSetpoint;
   public @Nullable Integer coolSetpoint;
+  private static final long TRANSITION_TIME_ID = 0L;
+  private static final long HEAT_SETPOINT_ID = 1L;
+  private static final long COOL_SETPOINT_ID = 2L;
+
   public ThermostatClusterThermostatScheduleTransition(
     Integer transitionTime,
     @Nullable Integer heatSetpoint,
@@ -2088,6 +5082,47 @@ public ThermostatClusterThermostatScheduleTransition(
     this.coolSetpoint = coolSetpoint;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(TRANSITION_TIME_ID, new UIntType(transitionTime)));
+    values.add(new StructElement(HEAT_SETPOINT_ID, heatSetpoint != null ? new IntType(heatSetpoint) : new NullType()));
+    values.add(new StructElement(COOL_SETPOINT_ID, coolSetpoint != null ? new IntType(coolSetpoint) : new NullType()));
+
+    return new StructType(values);
+  }
+
+  public static ThermostatClusterThermostatScheduleTransition decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer transitionTime = null;
+    @Nullable Integer heatSetpoint = null;
+    @Nullable Integer coolSetpoint = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == TRANSITION_TIME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          transitionTime = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == HEAT_SETPOINT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Int) {
+          IntType castingValue = element.value(IntType.class);
+          heatSetpoint = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == COOL_SETPOINT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Int) {
+          IntType castingValue = element.value(IntType.class);
+          coolSetpoint = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new ThermostatClusterThermostatScheduleTransition(
+      transitionTime,
+      heatSetpoint,
+      coolSetpoint
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2111,6 +5146,12 @@ public static class ChannelClusterChannelInfoStruct {
   public Optional<String> name;
   public Optional<String> callSign;
   public Optional<String> affiliateCallSign;
+  private static final long MAJOR_NUMBER_ID = 0L;
+  private static final long MINOR_NUMBER_ID = 1L;
+  private static final long NAME_ID = 2L;
+  private static final long CALL_SIGN_ID = 3L;
+  private static final long AFFILIATE_CALL_SIGN_ID = 4L;
+
   public ChannelClusterChannelInfoStruct(
     Integer majorNumber,
     Integer minorNumber,
@@ -2125,6 +5166,63 @@ public ChannelClusterChannelInfoStruct(
     this.affiliateCallSign = affiliateCallSign;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(MAJOR_NUMBER_ID, new UIntType(majorNumber)));
+    values.add(new StructElement(MINOR_NUMBER_ID, new UIntType(minorNumber)));
+    values.add(new StructElement(NAME_ID, name.<BaseTLVType>map((nonOptionalname) -> new StringType(nonOptionalname)).orElse(new EmptyType())));
+    values.add(new StructElement(CALL_SIGN_ID, callSign.<BaseTLVType>map((nonOptionalcallSign) -> new StringType(nonOptionalcallSign)).orElse(new EmptyType())));
+    values.add(new StructElement(AFFILIATE_CALL_SIGN_ID, affiliateCallSign.<BaseTLVType>map((nonOptionalaffiliateCallSign) -> new StringType(nonOptionalaffiliateCallSign)).orElse(new EmptyType())));
+
+    return new StructType(values);
+  }
+
+  public static ChannelClusterChannelInfoStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer majorNumber = null;
+    Integer minorNumber = null;
+    Optional<String> name = Optional.empty();
+    Optional<String> callSign = Optional.empty();
+    Optional<String> affiliateCallSign = Optional.empty();
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == MAJOR_NUMBER_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          majorNumber = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == MINOR_NUMBER_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          minorNumber = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == NAME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          name = Optional.of(castingValue.value(String.class));
+        }
+      } else if (element.contextTagNum() == CALL_SIGN_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          callSign = Optional.of(castingValue.value(String.class));
+        }
+      } else if (element.contextTagNum() == AFFILIATE_CALL_SIGN_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          affiliateCallSign = Optional.of(castingValue.value(String.class));
+        }
+      }
+    }
+    return new ChannelClusterChannelInfoStruct(
+      majorNumber,
+      minorNumber,
+      name,
+      callSign,
+      affiliateCallSign
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2153,6 +5251,11 @@ public static class ChannelClusterLineupInfoStruct {
   public Optional<String> lineupName;
   public Optional<String> postalCode;
   public Integer lineupInfoType;
+  private static final long OPERATOR_NAME_ID = 0L;
+  private static final long LINEUP_NAME_ID = 1L;
+  private static final long POSTAL_CODE_ID = 2L;
+  private static final long LINEUP_INFO_TYPE_ID = 3L;
+
   public ChannelClusterLineupInfoStruct(
     String operatorName,
     Optional<String> lineupName,
@@ -2165,6 +5268,55 @@ public ChannelClusterLineupInfoStruct(
     this.lineupInfoType = lineupInfoType;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(OPERATOR_NAME_ID, new StringType(operatorName)));
+    values.add(new StructElement(LINEUP_NAME_ID, lineupName.<BaseTLVType>map((nonOptionallineupName) -> new StringType(nonOptionallineupName)).orElse(new EmptyType())));
+    values.add(new StructElement(POSTAL_CODE_ID, postalCode.<BaseTLVType>map((nonOptionalpostalCode) -> new StringType(nonOptionalpostalCode)).orElse(new EmptyType())));
+    values.add(new StructElement(LINEUP_INFO_TYPE_ID, new UIntType(lineupInfoType)));
+
+    return new StructType(values);
+  }
+
+  public static ChannelClusterLineupInfoStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    String operatorName = null;
+    Optional<String> lineupName = Optional.empty();
+    Optional<String> postalCode = Optional.empty();
+    Integer lineupInfoType = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == OPERATOR_NAME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          operatorName = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == LINEUP_NAME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          lineupName = Optional.of(castingValue.value(String.class));
+        }
+      } else if (element.contextTagNum() == POSTAL_CODE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          postalCode = Optional.of(castingValue.value(String.class));
+        }
+      } else if (element.contextTagNum() == LINEUP_INFO_TYPE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          lineupInfoType = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new ChannelClusterLineupInfoStruct(
+      operatorName,
+      lineupName,
+      postalCode,
+      lineupInfoType
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2188,6 +5340,9 @@ public String toString() {
 public static class TargetNavigatorClusterTargetInfoStruct {
   public Integer identifier;
   public String name;
+  private static final long IDENTIFIER_ID = 0L;
+  private static final long NAME_ID = 1L;
+
   public TargetNavigatorClusterTargetInfoStruct(
     Integer identifier,
     String name
@@ -2196,6 +5351,39 @@ public TargetNavigatorClusterTargetInfoStruct(
     this.name = name;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(IDENTIFIER_ID, new UIntType(identifier)));
+    values.add(new StructElement(NAME_ID, new StringType(name)));
+
+    return new StructType(values);
+  }
+
+  public static TargetNavigatorClusterTargetInfoStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer identifier = null;
+    String name = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == IDENTIFIER_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          identifier = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == NAME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          name = castingValue.value(String.class);
+        }
+      }
+    }
+    return new TargetNavigatorClusterTargetInfoStruct(
+      identifier,
+      name
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2213,6 +5401,9 @@ public String toString() {
 public static class MediaPlaybackClusterPlaybackPositionStruct {
   public Long updatedAt;
   public @Nullable Long position;
+  private static final long UPDATED_AT_ID = 0L;
+  private static final long POSITION_ID = 1L;
+
   public MediaPlaybackClusterPlaybackPositionStruct(
     Long updatedAt,
     @Nullable Long position
@@ -2221,6 +5412,39 @@ public MediaPlaybackClusterPlaybackPositionStruct(
     this.position = position;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(UPDATED_AT_ID, new UIntType(updatedAt)));
+    values.add(new StructElement(POSITION_ID, position != null ? new UIntType(position) : new NullType()));
+
+    return new StructType(values);
+  }
+
+  public static MediaPlaybackClusterPlaybackPositionStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Long updatedAt = null;
+    @Nullable Long position = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == UPDATED_AT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          updatedAt = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == POSITION_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          position = castingValue.value(Long.class);
+        }
+      }
+    }
+    return new MediaPlaybackClusterPlaybackPositionStruct(
+      updatedAt,
+      position
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2240,6 +5464,11 @@ public static class MediaInputClusterInputInfoStruct {
   public Integer inputType;
   public String name;
   public String description;
+  private static final long INDEX_ID = 0L;
+  private static final long INPUT_TYPE_ID = 1L;
+  private static final long NAME_ID = 2L;
+  private static final long DESCRIPTION_ID = 3L;
+
   public MediaInputClusterInputInfoStruct(
     Integer index,
     Integer inputType,
@@ -2252,6 +5481,55 @@ public MediaInputClusterInputInfoStruct(
     this.description = description;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(INDEX_ID, new UIntType(index)));
+    values.add(new StructElement(INPUT_TYPE_ID, new UIntType(inputType)));
+    values.add(new StructElement(NAME_ID, new StringType(name)));
+    values.add(new StructElement(DESCRIPTION_ID, new StringType(description)));
+
+    return new StructType(values);
+  }
+
+  public static MediaInputClusterInputInfoStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer index = null;
+    Integer inputType = null;
+    String name = null;
+    String description = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          index = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == INPUT_TYPE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          inputType = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == NAME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          name = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == DESCRIPTION_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          description = castingValue.value(String.class);
+        }
+      }
+    }
+    return new MediaInputClusterInputInfoStruct(
+      index,
+      inputType,
+      name,
+      description
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2276,6 +5554,10 @@ public static class ContentLauncherClusterDimensionStruct {
   public Double width;
   public Double height;
   public Integer metric;
+  private static final long WIDTH_ID = 0L;
+  private static final long HEIGHT_ID = 1L;
+  private static final long METRIC_ID = 2L;
+
   public ContentLauncherClusterDimensionStruct(
     Double width,
     Double height,
@@ -2286,6 +5568,47 @@ public ContentLauncherClusterDimensionStruct(
     this.metric = metric;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(WIDTH_ID, new DoubleType(width)));
+    values.add(new StructElement(HEIGHT_ID, new DoubleType(height)));
+    values.add(new StructElement(METRIC_ID, new UIntType(metric)));
+
+    return new StructType(values);
+  }
+
+  public static ContentLauncherClusterDimensionStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Double width = null;
+    Double height = null;
+    Integer metric = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == WIDTH_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Double) {
+          DoubleType castingValue = element.value(DoubleType.class);
+          width = castingValue.value(Double.class);
+        }
+      } else if (element.contextTagNum() == HEIGHT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Double) {
+          DoubleType castingValue = element.value(DoubleType.class);
+          height = castingValue.value(Double.class);
+        }
+      } else if (element.contextTagNum() == METRIC_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          metric = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new ContentLauncherClusterDimensionStruct(
+      width,
+      height,
+      metric
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2306,6 +5629,9 @@ public String toString() {
 public static class ContentLauncherClusterAdditionalInfoStruct {
   public String name;
   public String value;
+  private static final long NAME_ID = 0L;
+  private static final long VALUE_ID = 1L;
+
   public ContentLauncherClusterAdditionalInfoStruct(
     String name,
     String value
@@ -2314,6 +5640,39 @@ public ContentLauncherClusterAdditionalInfoStruct(
     this.value = value;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(NAME_ID, new StringType(name)));
+    values.add(new StructElement(VALUE_ID, new StringType(value)));
+
+    return new StructType(values);
+  }
+
+  public static ContentLauncherClusterAdditionalInfoStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    String name = null;
+    String value = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == NAME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          name = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == VALUE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          value = castingValue.value(String.class);
+        }
+      }
+    }
+    return new ContentLauncherClusterAdditionalInfoStruct(
+      name,
+      value
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2332,6 +5691,10 @@ public static class ContentLauncherClusterParameterStruct {
   public Integer type;
   public String value;
   public Optional<ArrayList<ChipStructs.ContentLauncherClusterAdditionalInfoStruct>> externalIDList;
+  private static final long TYPE_ID = 0L;
+  private static final long VALUE_ID = 1L;
+  private static final long EXTERNAL_I_D_LIST_ID = 2L;
+
   public ContentLauncherClusterParameterStruct(
     Integer type,
     String value,
@@ -2342,6 +5705,47 @@ public ContentLauncherClusterParameterStruct(
     this.externalIDList = externalIDList;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(TYPE_ID, new UIntType(type)));
+    values.add(new StructElement(VALUE_ID, new StringType(value)));
+    values.add(new StructElement(EXTERNAL_I_D_LIST_ID, externalIDList.<BaseTLVType>map((nonOptionalexternalIDList) -> ArrayType.generateArrayType(nonOptionalexternalIDList, (elementnonOptionalexternalIDList) -> elementnonOptionalexternalIDList.encodeTlv())).orElse(new EmptyType())));
+
+    return new StructType(values);
+  }
+
+  public static ContentLauncherClusterParameterStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer type = null;
+    String value = null;
+    Optional<ArrayList<ChipStructs.ContentLauncherClusterAdditionalInfoStruct>> externalIDList = Optional.empty();
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == TYPE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          type = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == VALUE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          value = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == EXTERNAL_I_D_LIST_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          externalIDList = Optional.of(castingValue.map((elementcastingValue) -> ChipStructs.ContentLauncherClusterAdditionalInfoStruct.decodeTlv(elementcastingValue)));
+        }
+      }
+    }
+    return new ContentLauncherClusterParameterStruct(
+      type,
+      value,
+      externalIDList
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2361,12 +5765,39 @@ public String toString() {
 }
 public static class ContentLauncherClusterContentSearchStruct {
   public ArrayList<ChipStructs.ContentLauncherClusterParameterStruct> parameterList;
+  private static final long PARAMETER_LIST_ID = 0L;
+
   public ContentLauncherClusterContentSearchStruct(
     ArrayList<ChipStructs.ContentLauncherClusterParameterStruct> parameterList
   ) {
     this.parameterList = parameterList;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(PARAMETER_LIST_ID, ArrayType.generateArrayType(parameterList, (elementparameterList) -> elementparameterList.encodeTlv())));
+
+    return new StructType(values);
+  }
+
+  public static ContentLauncherClusterContentSearchStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    ArrayList<ChipStructs.ContentLauncherClusterParameterStruct> parameterList = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == PARAMETER_LIST_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          parameterList = castingValue.map((elementcastingValue) -> ChipStructs.ContentLauncherClusterParameterStruct.decodeTlv(elementcastingValue));
+        }
+      }
+    }
+    return new ContentLauncherClusterContentSearchStruct(
+      parameterList
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2382,6 +5813,10 @@ public static class ContentLauncherClusterStyleInformationStruct {
   public Optional<String> imageURL;
   public Optional<String> color;
   public Optional<ChipStructs.ContentLauncherClusterDimensionStruct> size;
+  private static final long IMAGE_U_R_L_ID = 0L;
+  private static final long COLOR_ID = 1L;
+  private static final long SIZE_ID = 2L;
+
   public ContentLauncherClusterStyleInformationStruct(
     Optional<String> imageURL,
     Optional<String> color,
@@ -2392,6 +5827,47 @@ public ContentLauncherClusterStyleInformationStruct(
     this.size = size;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(IMAGE_U_R_L_ID, imageURL.<BaseTLVType>map((nonOptionalimageURL) -> new StringType(nonOptionalimageURL)).orElse(new EmptyType())));
+    values.add(new StructElement(COLOR_ID, color.<BaseTLVType>map((nonOptionalcolor) -> new StringType(nonOptionalcolor)).orElse(new EmptyType())));
+    values.add(new StructElement(SIZE_ID, size.<BaseTLVType>map((nonOptionalsize) -> nonOptionalsize.encodeTlv()).orElse(new EmptyType())));
+
+    return new StructType(values);
+  }
+
+  public static ContentLauncherClusterStyleInformationStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Optional<String> imageURL = Optional.empty();
+    Optional<String> color = Optional.empty();
+    Optional<ChipStructs.ContentLauncherClusterDimensionStruct> size = Optional.empty();
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == IMAGE_U_R_L_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          imageURL = Optional.of(castingValue.value(String.class));
+        }
+      } else if (element.contextTagNum() == COLOR_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          color = Optional.of(castingValue.value(String.class));
+        }
+      } else if (element.contextTagNum() == SIZE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+          StructType castingValue = element.value(StructType.class);
+          size = Optional.of(ChipStructs.ContentLauncherClusterDimensionStruct.decodeTlv(castingValue));
+        }
+      }
+    }
+    return new ContentLauncherClusterStyleInformationStruct(
+      imageURL,
+      color,
+      size
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2416,6 +5892,13 @@ public static class ContentLauncherClusterBrandingInformationStruct {
   public Optional<ChipStructs.ContentLauncherClusterStyleInformationStruct> progressBar;
   public Optional<ChipStructs.ContentLauncherClusterStyleInformationStruct> splash;
   public Optional<ChipStructs.ContentLauncherClusterStyleInformationStruct> waterMark;
+  private static final long PROVIDER_NAME_ID = 0L;
+  private static final long BACKGROUND_ID = 1L;
+  private static final long LOGO_ID = 2L;
+  private static final long PROGRESS_BAR_ID = 3L;
+  private static final long SPLASH_ID = 4L;
+  private static final long WATER_MARK_ID = 5L;
+
   public ContentLauncherClusterBrandingInformationStruct(
     String providerName,
     Optional<ChipStructs.ContentLauncherClusterStyleInformationStruct> background,
@@ -2432,6 +5915,71 @@ public ContentLauncherClusterBrandingInformationStruct(
     this.waterMark = waterMark;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(PROVIDER_NAME_ID, new StringType(providerName)));
+    values.add(new StructElement(BACKGROUND_ID, background.<BaseTLVType>map((nonOptionalbackground) -> nonOptionalbackground.encodeTlv()).orElse(new EmptyType())));
+    values.add(new StructElement(LOGO_ID, logo.<BaseTLVType>map((nonOptionallogo) -> nonOptionallogo.encodeTlv()).orElse(new EmptyType())));
+    values.add(new StructElement(PROGRESS_BAR_ID, progressBar.<BaseTLVType>map((nonOptionalprogressBar) -> nonOptionalprogressBar.encodeTlv()).orElse(new EmptyType())));
+    values.add(new StructElement(SPLASH_ID, splash.<BaseTLVType>map((nonOptionalsplash) -> nonOptionalsplash.encodeTlv()).orElse(new EmptyType())));
+    values.add(new StructElement(WATER_MARK_ID, waterMark.<BaseTLVType>map((nonOptionalwaterMark) -> nonOptionalwaterMark.encodeTlv()).orElse(new EmptyType())));
+
+    return new StructType(values);
+  }
+
+  public static ContentLauncherClusterBrandingInformationStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    String providerName = null;
+    Optional<ChipStructs.ContentLauncherClusterStyleInformationStruct> background = Optional.empty();
+    Optional<ChipStructs.ContentLauncherClusterStyleInformationStruct> logo = Optional.empty();
+    Optional<ChipStructs.ContentLauncherClusterStyleInformationStruct> progressBar = Optional.empty();
+    Optional<ChipStructs.ContentLauncherClusterStyleInformationStruct> splash = Optional.empty();
+    Optional<ChipStructs.ContentLauncherClusterStyleInformationStruct> waterMark = Optional.empty();
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == PROVIDER_NAME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          providerName = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == BACKGROUND_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+          StructType castingValue = element.value(StructType.class);
+          background = Optional.of(ChipStructs.ContentLauncherClusterStyleInformationStruct.decodeTlv(castingValue));
+        }
+      } else if (element.contextTagNum() == LOGO_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+          StructType castingValue = element.value(StructType.class);
+          logo = Optional.of(ChipStructs.ContentLauncherClusterStyleInformationStruct.decodeTlv(castingValue));
+        }
+      } else if (element.contextTagNum() == PROGRESS_BAR_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+          StructType castingValue = element.value(StructType.class);
+          progressBar = Optional.of(ChipStructs.ContentLauncherClusterStyleInformationStruct.decodeTlv(castingValue));
+        }
+      } else if (element.contextTagNum() == SPLASH_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+          StructType castingValue = element.value(StructType.class);
+          splash = Optional.of(ChipStructs.ContentLauncherClusterStyleInformationStruct.decodeTlv(castingValue));
+        }
+      } else if (element.contextTagNum() == WATER_MARK_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+          StructType castingValue = element.value(StructType.class);
+          waterMark = Optional.of(ChipStructs.ContentLauncherClusterStyleInformationStruct.decodeTlv(castingValue));
+        }
+      }
+    }
+    return new ContentLauncherClusterBrandingInformationStruct(
+      providerName,
+      background,
+      logo,
+      progressBar,
+      splash,
+      waterMark
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2462,6 +6010,10 @@ public static class AudioOutputClusterOutputInfoStruct {
   public Integer index;
   public Integer outputType;
   public String name;
+  private static final long INDEX_ID = 0L;
+  private static final long OUTPUT_TYPE_ID = 1L;
+  private static final long NAME_ID = 2L;
+
   public AudioOutputClusterOutputInfoStruct(
     Integer index,
     Integer outputType,
@@ -2472,6 +6024,47 @@ public AudioOutputClusterOutputInfoStruct(
     this.name = name;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(INDEX_ID, new UIntType(index)));
+    values.add(new StructElement(OUTPUT_TYPE_ID, new UIntType(outputType)));
+    values.add(new StructElement(NAME_ID, new StringType(name)));
+
+    return new StructType(values);
+  }
+
+  public static AudioOutputClusterOutputInfoStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer index = null;
+    Integer outputType = null;
+    String name = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          index = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == OUTPUT_TYPE_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          outputType = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == NAME_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          name = castingValue.value(String.class);
+        }
+      }
+    }
+    return new AudioOutputClusterOutputInfoStruct(
+      index,
+      outputType,
+      name
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2492,6 +6085,9 @@ public String toString() {
 public static class ApplicationLauncherClusterApplicationStruct {
   public Integer catalogVendorID;
   public String applicationID;
+  private static final long CATALOG_VENDOR_I_D_ID = 0L;
+  private static final long APPLICATION_I_D_ID = 1L;
+
   public ApplicationLauncherClusterApplicationStruct(
     Integer catalogVendorID,
     String applicationID
@@ -2500,6 +6096,39 @@ public ApplicationLauncherClusterApplicationStruct(
     this.applicationID = applicationID;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(CATALOG_VENDOR_I_D_ID, new UIntType(catalogVendorID)));
+    values.add(new StructElement(APPLICATION_I_D_ID, new StringType(applicationID)));
+
+    return new StructType(values);
+  }
+
+  public static ApplicationLauncherClusterApplicationStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer catalogVendorID = null;
+    String applicationID = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == CATALOG_VENDOR_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          catalogVendorID = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == APPLICATION_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          applicationID = castingValue.value(String.class);
+        }
+      }
+    }
+    return new ApplicationLauncherClusterApplicationStruct(
+      catalogVendorID,
+      applicationID
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2517,6 +6146,9 @@ public String toString() {
 public static class ApplicationLauncherClusterApplicationEPStruct {
   public ChipStructs.ApplicationLauncherClusterApplicationStruct application;
   public Optional<Integer> endpoint;
+  private static final long APPLICATION_ID = 0L;
+  private static final long ENDPOINT_ID = 1L;
+
   public ApplicationLauncherClusterApplicationEPStruct(
     ChipStructs.ApplicationLauncherClusterApplicationStruct application,
     Optional<Integer> endpoint
@@ -2525,6 +6157,39 @@ public ApplicationLauncherClusterApplicationEPStruct(
     this.endpoint = endpoint;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(APPLICATION_ID, application.encodeTlv()));
+    values.add(new StructElement(ENDPOINT_ID, endpoint.<BaseTLVType>map((nonOptionalendpoint) -> new UIntType(nonOptionalendpoint)).orElse(new EmptyType())));
+
+    return new StructType(values);
+  }
+
+  public static ApplicationLauncherClusterApplicationEPStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    ChipStructs.ApplicationLauncherClusterApplicationStruct application = null;
+    Optional<Integer> endpoint = Optional.empty();
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == APPLICATION_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+          StructType castingValue = element.value(StructType.class);
+          application = ChipStructs.ApplicationLauncherClusterApplicationStruct.decodeTlv(castingValue);
+        }
+      } else if (element.contextTagNum() == ENDPOINT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          endpoint = Optional.of(castingValue.value(Integer.class));
+        }
+      }
+    }
+    return new ApplicationLauncherClusterApplicationEPStruct(
+      application,
+      endpoint
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2542,6 +6207,9 @@ public String toString() {
 public static class ApplicationBasicClusterApplicationStruct {
   public Integer catalogVendorID;
   public String applicationID;
+  private static final long CATALOG_VENDOR_I_D_ID = 0L;
+  private static final long APPLICATION_I_D_ID = 1L;
+
   public ApplicationBasicClusterApplicationStruct(
     Integer catalogVendorID,
     String applicationID
@@ -2550,6 +6218,39 @@ public ApplicationBasicClusterApplicationStruct(
     this.applicationID = applicationID;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(CATALOG_VENDOR_I_D_ID, new UIntType(catalogVendorID)));
+    values.add(new StructElement(APPLICATION_I_D_ID, new StringType(applicationID)));
+
+    return new StructType(values);
+  }
+
+  public static ApplicationBasicClusterApplicationStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer catalogVendorID = null;
+    String applicationID = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == CATALOG_VENDOR_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          catalogVendorID = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == APPLICATION_I_D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          applicationID = castingValue.value(String.class);
+        }
+      }
+    }
+    return new ApplicationBasicClusterApplicationStruct(
+      catalogVendorID,
+      applicationID
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2573,6 +6274,15 @@ public static class UnitTestingClusterSimpleStruct {
   public Integer f;
   public Float g;
   public Double h;
+  private static final long A_ID = 0L;
+  private static final long B_ID = 1L;
+  private static final long C_ID = 2L;
+  private static final long D_ID = 3L;
+  private static final long E_ID = 4L;
+  private static final long F_ID = 5L;
+  private static final long G_ID = 6L;
+  private static final long H_ID = 7L;
+
   public UnitTestingClusterSimpleStruct(
     Integer a,
     Boolean b,
@@ -2593,6 +6303,87 @@ public UnitTestingClusterSimpleStruct(
     this.h = h;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(A_ID, new UIntType(a)));
+    values.add(new StructElement(B_ID, new BooleanType(b)));
+    values.add(new StructElement(C_ID, new UIntType(c)));
+    values.add(new StructElement(D_ID, new ByteArrayType(d)));
+    values.add(new StructElement(E_ID, new StringType(e)));
+    values.add(new StructElement(F_ID, new UIntType(f)));
+    values.add(new StructElement(G_ID, new FloatType(g)));
+    values.add(new StructElement(H_ID, new DoubleType(h)));
+
+    return new StructType(values);
+  }
+
+  public static UnitTestingClusterSimpleStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer a = null;
+    Boolean b = null;
+    Integer c = null;
+    byte[] d = null;
+    String e = null;
+    Integer f = null;
+    Float g = null;
+    Double h = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == A_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          a = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == B_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          b = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == C_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          c = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+          ByteArrayType castingValue = element.value(ByteArrayType.class);
+          d = castingValue.value(byte[].class);
+        }
+      } else if (element.contextTagNum() == E_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          e = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == F_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          f = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == G_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Float) {
+          FloatType castingValue = element.value(FloatType.class);
+          g = castingValue.value(Float.class);
+        }
+      } else if (element.contextTagNum() == H_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Double) {
+          DoubleType castingValue = element.value(DoubleType.class);
+          h = castingValue.value(Double.class);
+        }
+      }
+    }
+    return new UnitTestingClusterSimpleStruct(
+      a,
+      b,
+      c,
+      d,
+      e,
+      f,
+      g,
+      h
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2634,6 +6425,15 @@ public static class UnitTestingClusterTestFabricScoped {
   public ChipStructs.UnitTestingClusterSimpleStruct fabricSensitiveStruct;
   public ArrayList<Integer> fabricSensitiveInt8uList;
   public Integer fabricIndex;
+  private static final long FABRIC_SENSITIVE_INT8U_ID = 1L;
+  private static final long OPTIONAL_FABRIC_SENSITIVE_INT8U_ID = 2L;
+  private static final long NULLABLE_FABRIC_SENSITIVE_INT8U_ID = 3L;
+  private static final long NULLABLE_OPTIONAL_FABRIC_SENSITIVE_INT8U_ID = 4L;
+  private static final long FABRIC_SENSITIVE_CHAR_STRING_ID = 5L;
+  private static final long FABRIC_SENSITIVE_STRUCT_ID = 6L;
+  private static final long FABRIC_SENSITIVE_INT8U_LIST_ID = 7L;
+  private static final long FABRIC_INDEX_ID = 254L;
+
   public UnitTestingClusterTestFabricScoped(
     Integer fabricSensitiveInt8u,
     Optional<Integer> optionalFabricSensitiveInt8u,
@@ -2654,6 +6454,87 @@ public UnitTestingClusterTestFabricScoped(
     this.fabricIndex = fabricIndex;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(FABRIC_SENSITIVE_INT8U_ID, new UIntType(fabricSensitiveInt8u)));
+    values.add(new StructElement(OPTIONAL_FABRIC_SENSITIVE_INT8U_ID, optionalFabricSensitiveInt8u.<BaseTLVType>map((nonOptionaloptionalFabricSensitiveInt8u) -> new UIntType(nonOptionaloptionalFabricSensitiveInt8u)).orElse(new EmptyType())));
+    values.add(new StructElement(NULLABLE_FABRIC_SENSITIVE_INT8U_ID, nullableFabricSensitiveInt8u != null ? new UIntType(nullableFabricSensitiveInt8u) : new NullType()));
+    values.add(new StructElement(NULLABLE_OPTIONAL_FABRIC_SENSITIVE_INT8U_ID, nullableOptionalFabricSensitiveInt8u != null ? nullableOptionalFabricSensitiveInt8u.<BaseTLVType>map((nonOptionalnullableOptionalFabricSensitiveInt8u) -> new UIntType(nonOptionalnullableOptionalFabricSensitiveInt8u)).orElse(new EmptyType()) : new NullType()));
+    values.add(new StructElement(FABRIC_SENSITIVE_CHAR_STRING_ID, new StringType(fabricSensitiveCharString)));
+    values.add(new StructElement(FABRIC_SENSITIVE_STRUCT_ID, fabricSensitiveStruct.encodeTlv()));
+    values.add(new StructElement(FABRIC_SENSITIVE_INT8U_LIST_ID, ArrayType.generateArrayType(fabricSensitiveInt8uList, (elementfabricSensitiveInt8uList) -> new UIntType(elementfabricSensitiveInt8uList))));
+    values.add(new StructElement(FABRIC_INDEX_ID, new UIntType(fabricIndex)));
+
+    return new StructType(values);
+  }
+
+  public static UnitTestingClusterTestFabricScoped decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer fabricSensitiveInt8u = null;
+    Optional<Integer> optionalFabricSensitiveInt8u = Optional.empty();
+    @Nullable Integer nullableFabricSensitiveInt8u = null;
+    @Nullable Optional<Integer> nullableOptionalFabricSensitiveInt8u = null;
+    String fabricSensitiveCharString = null;
+    ChipStructs.UnitTestingClusterSimpleStruct fabricSensitiveStruct = null;
+    ArrayList<Integer> fabricSensitiveInt8uList = null;
+    Integer fabricIndex = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == FABRIC_SENSITIVE_INT8U_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricSensitiveInt8u = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == OPTIONAL_FABRIC_SENSITIVE_INT8U_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          optionalFabricSensitiveInt8u = Optional.of(castingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == NULLABLE_FABRIC_SENSITIVE_INT8U_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          nullableFabricSensitiveInt8u = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == NULLABLE_OPTIONAL_FABRIC_SENSITIVE_INT8U_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          nullableOptionalFabricSensitiveInt8u = Optional.of(castingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == FABRIC_SENSITIVE_CHAR_STRING_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          fabricSensitiveCharString = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == FABRIC_SENSITIVE_STRUCT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+          StructType castingValue = element.value(StructType.class);
+          fabricSensitiveStruct = ChipStructs.UnitTestingClusterSimpleStruct.decodeTlv(castingValue);
+        }
+      } else if (element.contextTagNum() == FABRIC_SENSITIVE_INT8U_LIST_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          fabricSensitiveInt8uList = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == FABRIC_INDEX_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          fabricIndex = castingValue.value(Integer.class);
+        }
+      }
+    }
+    return new UnitTestingClusterTestFabricScoped(
+      fabricSensitiveInt8u,
+      optionalFabricSensitiveInt8u,
+      nullableFabricSensitiveInt8u,
+      nullableOptionalFabricSensitiveInt8u,
+      fabricSensitiveCharString,
+      fabricSensitiveStruct,
+      fabricSensitiveInt8uList,
+      fabricIndex
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2699,6 +6580,19 @@ public static class UnitTestingClusterNullablesAndOptionalsStruct {
   public @Nullable ArrayList<Integer> nullableList;
   public Optional<ArrayList<Integer>> optionalList;
   public @Nullable Optional<ArrayList<Integer>> nullableOptionalList;
+  private static final long NULLABLE_INT_ID = 0L;
+  private static final long OPTIONAL_INT_ID = 1L;
+  private static final long NULLABLE_OPTIONAL_INT_ID = 2L;
+  private static final long NULLABLE_STRING_ID = 3L;
+  private static final long OPTIONAL_STRING_ID = 4L;
+  private static final long NULLABLE_OPTIONAL_STRING_ID = 5L;
+  private static final long NULLABLE_STRUCT_ID = 6L;
+  private static final long OPTIONAL_STRUCT_ID = 7L;
+  private static final long NULLABLE_OPTIONAL_STRUCT_ID = 8L;
+  private static final long NULLABLE_LIST_ID = 9L;
+  private static final long OPTIONAL_LIST_ID = 10L;
+  private static final long NULLABLE_OPTIONAL_LIST_ID = 11L;
+
   public UnitTestingClusterNullablesAndOptionalsStruct(
     @Nullable Integer nullableInt,
     Optional<Integer> optionalInt,
@@ -2727,6 +6621,119 @@ public UnitTestingClusterNullablesAndOptionalsStruct(
     this.nullableOptionalList = nullableOptionalList;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(NULLABLE_INT_ID, nullableInt != null ? new UIntType(nullableInt) : new NullType()));
+    values.add(new StructElement(OPTIONAL_INT_ID, optionalInt.<BaseTLVType>map((nonOptionaloptionalInt) -> new UIntType(nonOptionaloptionalInt)).orElse(new EmptyType())));
+    values.add(new StructElement(NULLABLE_OPTIONAL_INT_ID, nullableOptionalInt != null ? nullableOptionalInt.<BaseTLVType>map((nonOptionalnullableOptionalInt) -> new UIntType(nonOptionalnullableOptionalInt)).orElse(new EmptyType()) : new NullType()));
+    values.add(new StructElement(NULLABLE_STRING_ID, nullableString != null ? new StringType(nullableString) : new NullType()));
+    values.add(new StructElement(OPTIONAL_STRING_ID, optionalString.<BaseTLVType>map((nonOptionaloptionalString) -> new StringType(nonOptionaloptionalString)).orElse(new EmptyType())));
+    values.add(new StructElement(NULLABLE_OPTIONAL_STRING_ID, nullableOptionalString != null ? nullableOptionalString.<BaseTLVType>map((nonOptionalnullableOptionalString) -> new StringType(nonOptionalnullableOptionalString)).orElse(new EmptyType()) : new NullType()));
+    values.add(new StructElement(NULLABLE_STRUCT_ID, nullableStruct != null ? nullableStruct.encodeTlv() : new NullType()));
+    values.add(new StructElement(OPTIONAL_STRUCT_ID, optionalStruct.<BaseTLVType>map((nonOptionaloptionalStruct) -> nonOptionaloptionalStruct.encodeTlv()).orElse(new EmptyType())));
+    values.add(new StructElement(NULLABLE_OPTIONAL_STRUCT_ID, nullableOptionalStruct != null ? nullableOptionalStruct.<BaseTLVType>map((nonOptionalnullableOptionalStruct) -> nonOptionalnullableOptionalStruct.encodeTlv()).orElse(new EmptyType()) : new NullType()));
+    values.add(new StructElement(NULLABLE_LIST_ID, nullableList != null ? ArrayType.generateArrayType(nullableList, (elementnullableList) -> new UIntType(elementnullableList)) : new NullType()));
+    values.add(new StructElement(OPTIONAL_LIST_ID, optionalList.<BaseTLVType>map((nonOptionaloptionalList) -> ArrayType.generateArrayType(nonOptionaloptionalList, (elementnonOptionaloptionalList) -> new UIntType(elementnonOptionaloptionalList))).orElse(new EmptyType())));
+    values.add(new StructElement(NULLABLE_OPTIONAL_LIST_ID, nullableOptionalList != null ? nullableOptionalList.<BaseTLVType>map((nonOptionalnullableOptionalList) -> ArrayType.generateArrayType(nonOptionalnullableOptionalList, (elementnonOptionalnullableOptionalList) -> new UIntType(elementnonOptionalnullableOptionalList))).orElse(new EmptyType()) : new NullType()));
+
+    return new StructType(values);
+  }
+
+  public static UnitTestingClusterNullablesAndOptionalsStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    @Nullable Integer nullableInt = null;
+    Optional<Integer> optionalInt = Optional.empty();
+    @Nullable Optional<Integer> nullableOptionalInt = null;
+    @Nullable String nullableString = null;
+    Optional<String> optionalString = Optional.empty();
+    @Nullable Optional<String> nullableOptionalString = null;
+    @Nullable ChipStructs.UnitTestingClusterSimpleStruct nullableStruct = null;
+    Optional<ChipStructs.UnitTestingClusterSimpleStruct> optionalStruct = Optional.empty();
+    @Nullable Optional<ChipStructs.UnitTestingClusterSimpleStruct> nullableOptionalStruct = null;
+    @Nullable ArrayList<Integer> nullableList = null;
+    Optional<ArrayList<Integer>> optionalList = Optional.empty();
+    @Nullable Optional<ArrayList<Integer>> nullableOptionalList = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == NULLABLE_INT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          nullableInt = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == OPTIONAL_INT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          optionalInt = Optional.of(castingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == NULLABLE_OPTIONAL_INT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          nullableOptionalInt = Optional.of(castingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == NULLABLE_STRING_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          nullableString = castingValue.value(String.class);
+        }
+      } else if (element.contextTagNum() == OPTIONAL_STRING_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          optionalString = Optional.of(castingValue.value(String.class));
+        }
+      } else if (element.contextTagNum() == NULLABLE_OPTIONAL_STRING_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.String) {
+          StringType castingValue = element.value(StringType.class);
+          nullableOptionalString = Optional.of(castingValue.value(String.class));
+        }
+      } else if (element.contextTagNum() == NULLABLE_STRUCT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+          StructType castingValue = element.value(StructType.class);
+          nullableStruct = ChipStructs.UnitTestingClusterSimpleStruct.decodeTlv(castingValue);
+        }
+      } else if (element.contextTagNum() == OPTIONAL_STRUCT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+          StructType castingValue = element.value(StructType.class);
+          optionalStruct = Optional.of(ChipStructs.UnitTestingClusterSimpleStruct.decodeTlv(castingValue));
+        }
+      } else if (element.contextTagNum() == NULLABLE_OPTIONAL_STRUCT_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+          StructType castingValue = element.value(StructType.class);
+          nullableOptionalStruct = Optional.of(ChipStructs.UnitTestingClusterSimpleStruct.decodeTlv(castingValue));
+        }
+      } else if (element.contextTagNum() == NULLABLE_LIST_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          nullableList = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      } else if (element.contextTagNum() == OPTIONAL_LIST_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          optionalList = Optional.of(castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class)));
+        }
+      } else if (element.contextTagNum() == NULLABLE_OPTIONAL_LIST_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          nullableOptionalList = Optional.of(castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class)));
+        }
+      }
+    }
+    return new UnitTestingClusterNullablesAndOptionalsStruct(
+      nullableInt,
+      optionalInt,
+      nullableOptionalInt,
+      nullableString,
+      optionalString,
+      nullableOptionalString,
+      nullableStruct,
+      optionalStruct,
+      nullableOptionalStruct,
+      nullableList,
+      optionalList,
+      nullableOptionalList
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2775,6 +6782,10 @@ public static class UnitTestingClusterNestedStruct {
   public Integer a;
   public Boolean b;
   public ChipStructs.UnitTestingClusterSimpleStruct c;
+  private static final long A_ID = 0L;
+  private static final long B_ID = 1L;
+  private static final long C_ID = 2L;
+
   public UnitTestingClusterNestedStruct(
     Integer a,
     Boolean b,
@@ -2785,6 +6796,47 @@ public UnitTestingClusterNestedStruct(
     this.c = c;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(A_ID, new UIntType(a)));
+    values.add(new StructElement(B_ID, new BooleanType(b)));
+    values.add(new StructElement(C_ID, c.encodeTlv()));
+
+    return new StructType(values);
+  }
+
+  public static UnitTestingClusterNestedStruct decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer a = null;
+    Boolean b = null;
+    ChipStructs.UnitTestingClusterSimpleStruct c = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == A_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          a = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == B_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          b = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == C_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+          StructType castingValue = element.value(StructType.class);
+          c = ChipStructs.UnitTestingClusterSimpleStruct.decodeTlv(castingValue);
+        }
+      }
+    }
+    return new UnitTestingClusterNestedStruct(
+      a,
+      b,
+      c
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2810,6 +6862,14 @@ public static class UnitTestingClusterNestedStructList {
   public ArrayList<Long> e;
   public ArrayList<byte[]> f;
   public ArrayList<Integer> g;
+  private static final long A_ID = 0L;
+  private static final long B_ID = 1L;
+  private static final long C_ID = 2L;
+  private static final long D_ID = 3L;
+  private static final long E_ID = 4L;
+  private static final long F_ID = 5L;
+  private static final long G_ID = 6L;
+
   public UnitTestingClusterNestedStructList(
     Integer a,
     Boolean b,
@@ -2828,6 +6888,79 @@ public UnitTestingClusterNestedStructList(
     this.g = g;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(A_ID, new UIntType(a)));
+    values.add(new StructElement(B_ID, new BooleanType(b)));
+    values.add(new StructElement(C_ID, c.encodeTlv()));
+    values.add(new StructElement(D_ID, ArrayType.generateArrayType(d, (elementd) -> elementd.encodeTlv())));
+    values.add(new StructElement(E_ID, ArrayType.generateArrayType(e, (elemente) -> new UIntType(elemente))));
+    values.add(new StructElement(F_ID, ArrayType.generateArrayType(f, (elementf) -> new ByteArrayType(elementf))));
+    values.add(new StructElement(G_ID, ArrayType.generateArrayType(g, (elementg) -> new UIntType(elementg))));
+
+    return new StructType(values);
+  }
+
+  public static UnitTestingClusterNestedStructList decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Integer a = null;
+    Boolean b = null;
+    ChipStructs.UnitTestingClusterSimpleStruct c = null;
+    ArrayList<ChipStructs.UnitTestingClusterSimpleStruct> d = null;
+    ArrayList<Long> e = null;
+    ArrayList<byte[]> f = null;
+    ArrayList<Integer> g = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == A_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          a = castingValue.value(Integer.class);
+        }
+      } else if (element.contextTagNum() == B_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Boolean) {
+          BooleanType castingValue = element.value(BooleanType.class);
+          b = castingValue.value(Boolean.class);
+        }
+      } else if (element.contextTagNum() == C_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Struct) {
+          StructType castingValue = element.value(StructType.class);
+          c = ChipStructs.UnitTestingClusterSimpleStruct.decodeTlv(castingValue);
+        }
+      } else if (element.contextTagNum() == D_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          d = castingValue.map((elementcastingValue) -> ChipStructs.UnitTestingClusterSimpleStruct.decodeTlv(elementcastingValue));
+        }
+      } else if (element.contextTagNum() == E_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          e = castingValue.map((elementcastingValue) -> elementcastingValue.value(Long.class));
+        }
+      } else if (element.contextTagNum() == F_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          f = castingValue.map((elementcastingValue) -> elementcastingValue.value(byte[].class));
+        }
+      } else if (element.contextTagNum() == G_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          g = castingValue.map((elementcastingValue) -> elementcastingValue.value(Integer.class));
+        }
+      }
+    }
+    return new UnitTestingClusterNestedStructList(
+      a,
+      b,
+      c,
+      d,
+      e,
+      f,
+      g
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2859,12 +6992,39 @@ public String toString() {
 }
 public static class UnitTestingClusterDoubleNestedStructList {
   public ArrayList<ChipStructs.UnitTestingClusterNestedStructList> a;
+  private static final long A_ID = 0L;
+
   public UnitTestingClusterDoubleNestedStructList(
     ArrayList<ChipStructs.UnitTestingClusterNestedStructList> a
   ) {
     this.a = a;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(A_ID, ArrayType.generateArrayType(a, (elementa) -> elementa.encodeTlv())));
+
+    return new StructType(values);
+  }
+
+  public static UnitTestingClusterDoubleNestedStructList decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    ArrayList<ChipStructs.UnitTestingClusterNestedStructList> a = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == A_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+          ArrayType castingValue = element.value(ArrayType.class);
+          a = castingValue.map((elementcastingValue) -> ChipStructs.UnitTestingClusterNestedStructList.decodeTlv(elementcastingValue));
+        }
+      }
+    }
+    return new UnitTestingClusterDoubleNestedStructList(
+      a
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
@@ -2879,6 +7039,9 @@ public String toString() {
 public static class UnitTestingClusterTestListStructOctet {
   public Long member1;
   public byte[] member2;
+  private static final long MEMBER1_ID = 0L;
+  private static final long MEMBER2_ID = 1L;
+
   public UnitTestingClusterTestListStructOctet(
     Long member1,
     byte[] member2
@@ -2887,6 +7050,39 @@ public UnitTestingClusterTestListStructOctet(
     this.member2 = member2;
   }
 
+  public StructType encodeTlv() {
+    ArrayList<StructElement> values = new ArrayList<>();
+    values.add(new StructElement(MEMBER1_ID, new UIntType(member1)));
+    values.add(new StructElement(MEMBER2_ID, new ByteArrayType(member2)));
+
+    return new StructType(values);
+  }
+
+  public static UnitTestingClusterTestListStructOctet decodeTlv(BaseTLVType tlvValue) {
+    if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+      return null;
+    }
+    Long member1 = null;
+    byte[] member2 = null;
+    for (StructElement element: ((StructType)tlvValue).value()) {
+      if (element.contextTagNum() == MEMBER1_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+          UIntType castingValue = element.value(UIntType.class);
+          member1 = castingValue.value(Long.class);
+        }
+      } else if (element.contextTagNum() == MEMBER2_ID) {
+        if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+          ByteArrayType castingValue = element.value(ByteArrayType.class);
+          member2 = castingValue.value(byte[].class);
+        }
+      }
+    }
+    return new UnitTestingClusterTestListStructOctet(
+      member1,
+      member2
+    );
+  }
+
   @Override
   public String toString() {
     StringBuilder output = new StringBuilder();
diff --git a/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java b/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java
index 95f65741bb4ca1..1173c6de35b43c 100644
--- a/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java
+++ b/src/controller/java/src/chip/devicecontroller/ChipDeviceController.java
@@ -1119,7 +1119,7 @@ public void shutdownCommissioning() {
   private native PaseVerifierParams computePaseVerifier(
       long deviceControllerPtr, long devicePtr, long setupPincode, long iterations, byte[] salt);
 
-  private native void subscribe(
+  static native void subscribe(
       long deviceControllerPtr,
       long callbackHandle,
       long devicePtr,
@@ -1132,7 +1132,7 @@ private native void subscribe(
       int imTimeoutMs,
       @Nullable Long eventMin);
 
-  private native void read(
+  static native void read(
       long deviceControllerPtr,
       long callbackHandle,
       long devicePtr,
@@ -1142,7 +1142,7 @@ private native void read(
       int imTimeoutMs,
       @Nullable Long eventMin);
 
-  private native void write(
+  static native void write(
       long deviceControllerPtr,
       long callbackHandle,
       long devicePtr,
@@ -1150,7 +1150,7 @@ private native void write(
       int timedRequestTimeoutMs,
       int imTimeoutMs);
 
-  private native void invoke(
+  static native void invoke(
       long deviceControllerPtr,
       long callbackHandle,
       long devicePtr,
diff --git a/src/controller/java/src/chip/devicecontroller/ChipTLVType.java b/src/controller/java/src/chip/devicecontroller/ChipTLVType.java
new file mode 100644
index 00000000000000..2ec14b975d508d
--- /dev/null
+++ b/src/controller/java/src/chip/devicecontroller/ChipTLVType.java
@@ -0,0 +1,366 @@
+package chip.devicecontroller;
+
+import java.util.ArrayList;
+
+public class ChipTLVType {
+  public enum TLVType {
+    UInt,
+    Int,
+    String,
+    ByteArray,
+    Boolean,
+    Float,
+    Double,
+    Null,
+    Struct,
+    Array,
+    Empty;
+  }
+
+  public static interface BaseTLVType {
+    TLVType type();
+
+    <T> T value(Class<T> clazz);
+  }
+
+  public static class UIntType implements BaseTLVType {
+    private long value;
+
+    public UIntType(long value) {
+      this.value = value;
+    }
+
+    @Override
+    public <T> T value(Class<T> clazz) {
+      Object ret;
+      if (clazz.equals(Integer.class)) {
+        ret = (int) value;
+      } else if (clazz.equals(Long.class)) {
+        ret = value;
+      } else {
+        throw new ClassCastException();
+      }
+
+      return clazz.cast(ret);
+    }
+
+    public long value() {
+      return value;
+    }
+
+    @Override
+    public TLVType type() {
+      return TLVType.UInt;
+    }
+  }
+
+  public static class IntType implements BaseTLVType {
+    private long value;
+
+    public IntType(long value) {
+      this.value = value;
+    }
+
+    @Override
+    public <T> T value(Class<T> clazz) {
+      Object ret;
+      if (clazz.equals(Integer.class)) {
+        ret = (int) value;
+      } else if (clazz.equals(Long.class)) {
+        ret = value;
+      } else {
+        throw new ClassCastException();
+      }
+
+      return clazz.cast(ret);
+    }
+
+    public long value() {
+      return value;
+    }
+
+    @Override
+    public TLVType type() {
+      return TLVType.Int;
+    }
+  }
+
+  public static class StringType implements BaseTLVType {
+    private String value;
+
+    public StringType(String value) {
+      this.value = value;
+    }
+
+    @Override
+    public <T> T value(Class<T> clazz) {
+      if (!clazz.equals(String.class)) {
+        throw new ClassCastException();
+      }
+
+      return clazz.cast(value);
+    }
+
+    public String value() {
+      return value;
+    }
+
+    @Override
+    public TLVType type() {
+      return TLVType.String;
+    }
+  }
+
+  public static class ByteArrayType implements BaseTLVType {
+    private byte[] value;
+
+    public ByteArrayType(byte[] value) {
+      this.value = value;
+    }
+
+    @Override
+    public <T> T value(Class<T> clazz) {
+      if (!clazz.equals(byte[].class)) {
+        throw new ClassCastException();
+      }
+
+      return clazz.cast(value);
+    }
+
+    public byte[] value() {
+      return value;
+    }
+
+    @Override
+    public TLVType type() {
+      return TLVType.ByteArray;
+    }
+  }
+
+  public static class BooleanType implements BaseTLVType {
+    private boolean value;
+
+    public BooleanType(boolean value) {
+      this.value = value;
+    }
+
+    @Override
+    public <T> T value(Class<T> clazz) {
+      if (!clazz.equals(Boolean.class)) {
+        throw new ClassCastException();
+      }
+
+      return clazz.cast(value);
+    }
+
+    public boolean value() {
+      return value;
+    }
+
+    @Override
+    public TLVType type() {
+      return TLVType.Boolean;
+    }
+  }
+
+  public static class FloatType implements BaseTLVType {
+    private float value;
+
+    public FloatType(float value) {
+      this.value = value;
+    }
+
+    @Override
+    public <T> T value(Class<T> clazz) {
+      if (!clazz.equals(Float.class)) {
+        throw new ClassCastException();
+      }
+
+      return clazz.cast(value);
+    }
+
+    public float value() {
+      return value;
+    }
+
+    @Override
+    public TLVType type() {
+      return TLVType.Float;
+    }
+  }
+
+  public static class DoubleType implements BaseTLVType {
+    private double value;
+
+    public DoubleType(double value) {
+      this.value = value;
+    }
+
+    @Override
+    public <T> T value(Class<T> clazz) {
+      if (!clazz.equals(Double.class)) {
+        throw new ClassCastException();
+      }
+
+      return clazz.cast(value);
+    }
+
+    public double value() {
+      return value;
+    }
+
+    @Override
+    public TLVType type() {
+      return TLVType.Double;
+    }
+  }
+
+  public static class NullType implements BaseTLVType {
+    @Override
+    public <T> T value(Class<T> clazz) {
+      return null;
+    }
+
+    @Override
+    public TLVType type() {
+      return TLVType.Null;
+    }
+  }
+
+  public static class StructType implements BaseTLVType {
+    private ArrayList<StructElement> value;
+
+    public StructType(ArrayList<StructElement> value) {
+      this.value = value;
+    }
+
+    @Override
+    public <T> T value(Class<T> clazz) {
+      if (!clazz.equals(ArrayList.class)) {
+        throw new ClassCastException();
+      }
+
+      return clazz.cast(value);
+    }
+
+    public ArrayList<StructElement> value() {
+      return value;
+    }
+
+    public StructElement value(int index) {
+      return value.get(index);
+    }
+
+    public int size() {
+      return value.size();
+    }
+
+    @Override
+    public TLVType type() {
+      return TLVType.Struct;
+    }
+  }
+
+  public static class StructElement {
+    private long contextTagNum;
+    private BaseTLVType value;
+
+    public StructElement(long contextTagNum, BaseTLVType value) {
+      this.contextTagNum = contextTagNum;
+      this.value = value;
+    }
+
+    public long contextTagNum() {
+      return contextTagNum;
+    }
+
+    public <T> T value(Class<T> clazz) {
+      try {
+        return clazz.cast(value);
+      } catch (ClassCastException e) {
+        return null;
+      }
+    }
+
+    public BaseTLVType value() {
+      return value;
+    }
+  }
+
+  public interface ArrayEncodeMapMethod<T> {
+    BaseTLVType map(T value);
+  }
+
+  public interface ArrayDecodeMapMethod<T> {
+    T map(BaseTLVType value);
+  }
+
+  public static class ArrayType implements BaseTLVType {
+    private ArrayList<BaseTLVType> value;
+
+    public ArrayType(ArrayList<BaseTLVType> value) {
+      this.value = value;
+    }
+
+    @Override
+    public <T> T value(Class<T> clazz) {
+      if (!clazz.equals(ArrayList.class)) {
+        throw new ClassCastException();
+      }
+
+      return clazz.cast(value);
+    }
+
+    public static <T> ArrayType generateArrayType(
+        ArrayList<T> rawValue, ArrayEncodeMapMethod<T> method) {
+      ArrayList<BaseTLVType> ret = new ArrayList<>();
+      for (T value : rawValue) {
+        ret.add(method.map(value));
+      }
+      return new ArrayType(ret);
+    }
+
+    public <T> ArrayList<T> map(ArrayDecodeMapMethod<T> method) {
+      ArrayList<T> ret = new ArrayList<>();
+      for (BaseTLVType v : value) {
+        ret.add(method.map(v));
+      }
+      return ret;
+    }
+
+    public <T> ArrayList<T> valuesAll(Class<T> clazz) {
+      try {
+        return this.<T>map(v -> clazz.cast(v));
+      } catch (ClassCastException e) {
+        return null;
+      }
+    }
+
+    public BaseTLVType value(int index) {
+      return value.get(index);
+    }
+
+    public int size() {
+      return value.size();
+    }
+
+    @Override
+    public TLVType type() {
+      return TLVType.Array;
+    }
+  }
+
+  public static class EmptyType implements BaseTLVType {
+    public EmptyType() {}
+
+    @Override
+    public <T> T value(Class<T> clazz) {
+      return null;
+    }
+
+    @Override
+    public TLVType type() {
+      return TLVType.Empty;
+    }
+  }
+}