diff --git a/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/CHIPToolActivity.kt b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/CHIPToolActivity.kt
index 7f96d1ad292b89..ce37951915e283 100644
--- a/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/CHIPToolActivity.kt
+++ b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/CHIPToolActivity.kt
@@ -28,7 +28,7 @@ import android.widget.Toast
 import androidx.appcompat.app.AlertDialog
 import androidx.appcompat.app.AppCompatActivity
 import androidx.fragment.app.Fragment
-import chip.devicecontroller.NetworkCredentials
+import com.google.chip.chiptool.NetworkCredentialsParcelable
 import chip.setuppayload.SetupPayload
 import chip.setuppayload.SetupPayloadParser
 import chip.setuppayload.SetupPayloadParser.UnrecognizedQrCodeException
@@ -133,7 +133,7 @@ class CHIPToolActivity :
     showFragment(AddressCommissioningFragment.newInstance(), false)
   }
 
-  override fun onNetworkCredentialsEntered(networkCredentials: NetworkCredentials) {
+  override fun onNetworkCredentialsEntered(networkCredentials: NetworkCredentialsParcelable) {
     showFragment(DeviceProvisioningFragment.newInstance(deviceInfo!!, networkCredentials))
   }
 
diff --git a/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/NetworkCredentialsParcelable.java b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/NetworkCredentialsParcelable.java
new file mode 100644
index 00000000000000..2194155f4f660b
--- /dev/null
+++ b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/NetworkCredentialsParcelable.java
@@ -0,0 +1,170 @@
+/*
+ *   Copyright (c) 2020-2022 Project CHIP Authors
+ *   All rights reserved.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+
+package com.google.chip.chiptool;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.Nullable;
+
+/** Class for holding WiFi or Thread credentials, but not both. */
+public class NetworkCredentialsParcelable implements Parcelable {
+  @Nullable private WiFiCredentials wifiCredentials;
+  @Nullable private ThreadCredentials threadCredentials;
+
+  private NetworkCredentialsParcelable(
+      @Nullable WiFiCredentials wifiCredentials, @Nullable ThreadCredentials threadCredentials) {
+    this.wifiCredentials = wifiCredentials;
+    this.threadCredentials = threadCredentials;
+  }
+
+  /**
+   * Return a NetworkCredentialsParcelable object with the given WiFiCredentials and null
+   * ThreadCredentials.
+   */
+  public static NetworkCredentialsParcelable forWiFi(WiFiCredentials wifiCredentials) {
+    return new NetworkCredentialsParcelable(wifiCredentials, null);
+  }
+
+  /**
+   * Return a NetworkCredentialsParcelable object with the given ThreadCredentials and null
+   * WiFiCredentials.
+   */
+  public static NetworkCredentialsParcelable forThread(ThreadCredentials threadCredentials) {
+    return new NetworkCredentialsParcelable(null, threadCredentials);
+  }
+
+  public WiFiCredentials getWiFiCredentials() {
+    return wifiCredentials;
+  }
+
+  public ThreadCredentials getThreadCredentials() {
+    return threadCredentials;
+  }
+
+  // Begin Parcelable implementation
+
+  private NetworkCredentialsParcelable(Parcel in) {
+    wifiCredentials = in.readParcelable(WiFiCredentials.class.getClassLoader());
+    threadCredentials = in.readParcelable(ThreadCredentials.class.getClassLoader());
+  }
+
+  public int describeContents() {
+    return 0;
+  }
+
+  public void writeToParcel(Parcel out, int flags) {
+    out.writeParcelable(wifiCredentials, 0);
+    out.writeParcelable(threadCredentials, 0);
+  }
+
+  public static final Parcelable.Creator<NetworkCredentialsParcelable> CREATOR =
+      new Parcelable.Creator<NetworkCredentialsParcelable>() {
+        public NetworkCredentialsParcelable createFromParcel(Parcel in) {
+          return new NetworkCredentialsParcelable(in);
+        }
+
+        public NetworkCredentialsParcelable[] newArray(int size) {
+          return new NetworkCredentialsParcelable[size];
+        }
+      };
+
+  public static class WiFiCredentials implements Parcelable {
+    private final String ssid;
+    private final String password;
+
+    public WiFiCredentials(String ssid, String password) {
+      this.ssid = ssid;
+      this.password = password;
+    }
+
+    public String getSsid() {
+      return ssid;
+    }
+
+    public String getPassword() {
+      return password;
+    }
+
+    // Begin Parcelable implementation
+
+    private WiFiCredentials(Parcel in) {
+      ssid = in.readString();
+      password = in.readString();
+    }
+
+    public int describeContents() {
+      return 0;
+    }
+
+    public void writeToParcel(Parcel out, int flags) {
+      out.writeString(ssid);
+      out.writeString(password);
+    }
+
+    public static final Parcelable.Creator<WiFiCredentials> CREATOR =
+        new Parcelable.Creator<WiFiCredentials>() {
+          public WiFiCredentials createFromParcel(Parcel in) {
+            return new WiFiCredentials(in);
+          }
+
+          public WiFiCredentials[] newArray(int size) {
+            return new WiFiCredentials[size];
+          }
+        };
+  }
+
+  public static class ThreadCredentials implements Parcelable {
+    private final byte[] operationalDataset;
+
+    public ThreadCredentials(byte[] operationalDataset) {
+      this.operationalDataset = operationalDataset;
+    }
+
+    public byte[] getOperationalDataset() {
+      return operationalDataset;
+    }
+
+    // Begin Parcelable implementation
+
+    private ThreadCredentials(Parcel in) {
+      operationalDataset = new byte[in.readInt()];
+      in.readByteArray(operationalDataset);
+    }
+
+    public int describeContents() {
+      return 0;
+    }
+
+    public void writeToParcel(Parcel out, int flags) {
+      out.writeInt(operationalDataset.length);
+      out.writeByteArray(operationalDataset);
+    }
+
+    public static final Parcelable.Creator<ThreadCredentials> CREATOR =
+        new Parcelable.Creator<ThreadCredentials>() {
+          public ThreadCredentials createFromParcel(Parcel in) {
+            return new ThreadCredentials(in);
+          }
+
+          public ThreadCredentials[] newArray(int size) {
+            return new ThreadCredentials[size];
+          }
+        };
+  }
+}
diff --git a/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/provisioning/DeviceProvisioningFragment.kt b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/provisioning/DeviceProvisioningFragment.kt
index f97647ce4ab18a..f816fabce45ead 100644
--- a/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/provisioning/DeviceProvisioningFragment.kt
+++ b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/provisioning/DeviceProvisioningFragment.kt
@@ -28,6 +28,7 @@ import android.widget.Toast
 import androidx.fragment.app.Fragment
 import androidx.lifecycle.lifecycleScope
 import chip.devicecontroller.NetworkCredentials
+import com.google.chip.chiptool.NetworkCredentialsParcelable
 import com.google.chip.chiptool.ChipClient
 import com.google.chip.chiptool.GenericChipDeviceListener
 import com.google.chip.chiptool.R
@@ -46,7 +47,7 @@ class DeviceProvisioningFragment : Fragment() {
 
   private var gatt: BluetoothGatt? = null
 
-  private val networkCredentials: NetworkCredentials?
+  private val networkCredentialsParcelable: NetworkCredentialsParcelable?
     get() = arguments?.getParcelable(ARG_NETWORK_CREDENTIALS)
 
   private lateinit var scope: CoroutineScope
@@ -120,7 +121,22 @@ class DeviceProvisioningFragment : Fragment() {
 
       val deviceId = DeviceIdUtil.getNextAvailableId(requireContext())
       val connId = bluetoothManager.connectionId
-      deviceController.pairDevice(gatt, connId, deviceId, deviceInfo.setupPinCode, networkCredentials)
+      val network = NetworkCredentials()
+      var networkParcelable = checkNotNull(networkCredentialsParcelable)
+
+      val wifi = networkParcelable.getWiFiCredentials()
+      if (wifi != null)
+      {
+        network.setWiFiCredentials(wifi.getSsid(), wifi.getPassword())
+      }
+
+      val thread = networkParcelable.getThreadCredentials()
+      if (thread != null)
+      {
+        network.setThreadCredentials(thread.getOperationalDataset())
+      }
+
+      deviceController.pairDevice(gatt, connId, deviceId, deviceInfo.setupPinCode, network)
       DeviceIdUtil.setNextAvailableId(requireContext(), deviceId + 1)
     }
   }
@@ -191,17 +207,17 @@ class DeviceProvisioningFragment : Fragment() {
     private const val STATUS_PAIRING_SUCCESS = 0
 
     /**
-     * Return a new instance of [DeviceProvisioningFragment]. [networkCredentials] can be null for
+     * Return a new instance of [DeviceProvisioningFragment]. [networkCredentialsParcelable] can be null for
      * IP commissioning.
      */
     fun newInstance(
       deviceInfo: CHIPDeviceInfo,
-      networkCredentials: NetworkCredentials?,
+      networkCredentialsParcelable: NetworkCredentialsParcelable?,
     ): DeviceProvisioningFragment {
       return DeviceProvisioningFragment().apply {
         arguments = Bundle(2).apply {
           putParcelable(ARG_DEVICE_INFO, deviceInfo)
-          putParcelable(ARG_NETWORK_CREDENTIALS, networkCredentials)
+          putParcelable(ARG_NETWORK_CREDENTIALS, networkCredentialsParcelable)
         }
       }
     }
diff --git a/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/provisioning/EnterNetworkFragment.kt b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/provisioning/EnterNetworkFragment.kt
index 9153b02c7fa266..5f0d024ee694a4 100644
--- a/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/provisioning/EnterNetworkFragment.kt
+++ b/examples/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/provisioning/EnterNetworkFragment.kt
@@ -23,9 +23,9 @@ import android.view.View
 import android.view.ViewGroup
 import android.widget.Toast
 import androidx.fragment.app.Fragment
-import chip.devicecontroller.NetworkCredentials
 import com.google.chip.chiptool.R
 import com.google.chip.chiptool.util.FragmentUtil
+import com.google.chip.chiptool.NetworkCredentialsParcelable
 import kotlinx.android.synthetic.main.enter_thread_network_fragment.channelEd
 import kotlinx.android.synthetic.main.enter_thread_network_fragment.masterKeyEd
 import kotlinx.android.synthetic.main.enter_thread_network_fragment.panIdEd
@@ -44,7 +44,7 @@ class EnterNetworkFragment : Fragment() {
     )
 
   interface Callback {
-    fun onNetworkCredentialsEntered(networkCredentials: NetworkCredentials)
+    fun onNetworkCredentialsEntered(networkCredentials: NetworkCredentialsParcelable)
   }
 
   override fun onCreateView(
@@ -79,8 +79,8 @@ class EnterNetworkFragment : Fragment() {
       return
     }
 
-    val networkCredentials = NetworkCredentials.forWiFi(
-      NetworkCredentials.WiFiCredentials(ssid.toString(), pwd.toString())
+    val networkCredentials = NetworkCredentialsParcelable.forWiFi(
+      NetworkCredentialsParcelable.WiFiCredentials(ssid.toString(), pwd.toString())
     )
     FragmentUtil.getHost(this, Callback::class.java)
       ?.onNetworkCredentialsEntered(networkCredentials)
@@ -130,7 +130,7 @@ class EnterNetworkFragment : Fragment() {
     )
 
     val networkCredentials =
-      NetworkCredentials.forThread(NetworkCredentials.ThreadCredentials(operationalDataset))
+      NetworkCredentialsParcelable.forThread(NetworkCredentialsParcelable.ThreadCredentials(operationalDataset))
     FragmentUtil.getHost(this, Callback::class.java)
       ?.onNetworkCredentialsEntered(networkCredentials)
   }
diff --git a/examples/android/CHIPTool/chip-library/build.gradle b/examples/android/CHIPTool/chip-library/build.gradle
index b6679efc9da1b4..429577ee6060aa 100644
--- a/examples/android/CHIPTool/chip-library/build.gradle
+++ b/examples/android/CHIPTool/chip-library/build.gradle
@@ -33,7 +33,8 @@ android {
                     '../../../setup_payload/java/src',
                     '../../../controller/java/zap-generated',
                     '../../../controller/java/src',
-                    '../../../platform/android/java'
+                    '../../../platform/android/java',
+                    '../app/src/main/java/com/google/chip/chiptool'
             ]
         }
     }
diff --git a/examples/light-switch-app/efr32/BUILD.gn b/examples/light-switch-app/efr32/BUILD.gn
index 8849f790d06bd8..7d71569cd0ff76 100644
--- a/examples/light-switch-app/efr32/BUILD.gn
+++ b/examples/light-switch-app/efr32/BUILD.gn
@@ -79,6 +79,7 @@ assert(!(use_wf200 && chip_enable_openthread))
 if (chip_enable_wifi) {
   assert(use_rs911x || use_wf200)
   enable_openthread_cli = false
+  import("${chip_root}/src/platform/EFR32/wifi_args.gni")
 }
 
 # ThunderBoards, Explorer Kit and MGM240L do not support LCD (No LCD)
@@ -92,14 +93,28 @@ if (silabs_board == "BRD4166A" || silabs_board == "BRD2601B" ||
 if (chip_enable_wifi) {
   wifi_sdk_dir = "${chip_root}/src/platform/EFR32/wifi"
   efr32_lwip_defs = [ "LWIP_NETIF_API=1" ]
-  efr32_lwip_defs += [
-    "LWIP_IPV4=1",
-    "LWIP_ARP=1",
-    "LWIP_ICMP=1",
-    "LWIP_DHCP=1",
-    "LWIP_IPV6_ND=1",
-    "LWIP_IGMP=1",
-  ]
+  if (lwip_ipv4) {
+    efr32_lwip_defs += [
+      "LWIP_IPV4=1",
+
+      # adds following options to provide
+      # them to .cpp source files
+      # flags ported from lwipopts file
+      # TODO: move lwipopts to one location
+      "LWIP_ARP=1",
+      "LWIP_ICMP=1",
+      "LWIP_IGMP=1",
+      "LWIP_DHCP=1",
+      "LWIP_DNS=0",
+    ]
+  } else {
+    efr32_lwip_defs += [ "LWIP_IPV4=0" ]
+  }
+  if (lwip_ipv6) {
+    efr32_lwip_defs += [ "LWIP_IPV6=1" ]
+  } else {
+    efr32_lwip_defs += [ "LWIP_IPV6=0" ]
+  }
 
   if (use_rs911x) {
     wiseconnect_sdk_root =
diff --git a/examples/lighting-app/efr32/BUILD.gn b/examples/lighting-app/efr32/BUILD.gn
index 0c36e3bba57314..1ca1b41e2ce62b 100644
--- a/examples/lighting-app/efr32/BUILD.gn
+++ b/examples/lighting-app/efr32/BUILD.gn
@@ -79,6 +79,7 @@ assert(!(use_wf200 && chip_enable_openthread))
 if (chip_enable_wifi) {
   assert(use_rs911x || use_wf200)
   enable_openthread_cli = false
+  import("${chip_root}/src/platform/EFR32/wifi_args.gni")
 }
 
 # ThunderBoards, Explorer Kit and MGM240L do not support LCD (No LCD)
@@ -97,14 +98,28 @@ if (chip_enable_wifi) {
   }
   wifi_sdk_dir = "${chip_root}/src/platform/EFR32/wifi"
   efr32_lwip_defs = [ "LWIP_NETIF_API=1" ]
-  efr32_lwip_defs += [
-    "LWIP_IPV4=1",
-    "LWIP_ARP=1",
-    "LWIP_ICMP=1",
-    "LWIP_DHCP=1",
-    "LWIP_IPV6_ND=1",
-    "LWIP_IGMP=1",
-  ]
+  if (lwip_ipv4) {
+    efr32_lwip_defs += [
+      "LWIP_IPV4=1",
+
+      # adds following options to provide
+      # them to .cpp source files
+      # flags ported from lwipopts file
+      # TODO: move lwipopts to one location
+      "LWIP_ARP=1",
+      "LWIP_ICMP=1",
+      "LWIP_IGMP=1",
+      "LWIP_DHCP=1",
+      "LWIP_DNS=0",
+    ]
+  } else {
+    efr32_lwip_defs += [ "LWIP_IPV4=0" ]
+  }
+  if (lwip_ipv6) {
+    efr32_lwip_defs += [ "LWIP_IPV6=1" ]
+  } else {
+    efr32_lwip_defs += [ "LWIP_IPV6=0" ]
+  }
 
   if (use_rs911x) {
     wiseconnect_sdk_root =
diff --git a/examples/lock-app/efr32/BUILD.gn b/examples/lock-app/efr32/BUILD.gn
index 996cb0f086a67d..fdd3f9f9984b8d 100644
--- a/examples/lock-app/efr32/BUILD.gn
+++ b/examples/lock-app/efr32/BUILD.gn
@@ -79,6 +79,7 @@ assert(!(use_wf200 && chip_enable_openthread))
 if (chip_enable_wifi) {
   assert(use_rs911x || use_wf200)
   enable_openthread_cli = false
+  import("${chip_root}/src/platform/EFR32/wifi_args.gni")
 }
 
 # ThunderBoards, Explorer Kit and MGM240L do not support LCD (No LCD)
@@ -92,14 +93,28 @@ if (silabs_board == "BRD4166A" || silabs_board == "BRD2601B" ||
 if (chip_enable_wifi) {
   wifi_sdk_dir = "${chip_root}/src/platform/EFR32/wifi"
   efr32_lwip_defs = [ "LWIP_NETIF_API=1" ]
-  efr32_lwip_defs += [
-    "LWIP_IPV4=1",
-    "LWIP_ARP=1",
-    "LWIP_ICMP=1",
-    "LWIP_DHCP=1",
-    "LWIP_IPV6_ND=1",
-    "LWIP_IGMP=1",
-  ]
+  if (lwip_ipv4) {
+    efr32_lwip_defs += [
+      "LWIP_IPV4=1",
+
+      # adds following options to provide
+      # them to .cpp source files
+      # flags ported from lwipopts file
+      # TODO: move lwipopts to one location
+      "LWIP_ARP=1",
+      "LWIP_ICMP=1",
+      "LWIP_IGMP=1",
+      "LWIP_DHCP=1",
+      "LWIP_DNS=0",
+    ]
+  } else {
+    efr32_lwip_defs += [ "LWIP_IPV4=0" ]
+  }
+  if (lwip_ipv6) {
+    efr32_lwip_defs += [ "LWIP_IPV6=1" ]
+  } else {
+    efr32_lwip_defs += [ "LWIP_IPV6=0" ]
+  }
 
   if (use_rs911x) {
     wiseconnect_sdk_root =
diff --git a/examples/lock-app/efr32/src/ZclCallbacks.cpp b/examples/lock-app/efr32/src/ZclCallbacks.cpp
index 650aba7d2d73de..9c1812a90c0a04 100644
--- a/examples/lock-app/efr32/src/ZclCallbacks.cpp
+++ b/examples/lock-app/efr32/src/ZclCallbacks.cpp
@@ -41,7 +41,9 @@ void MatterPostAttributeChangeCallback(const chip::app::ConcreteAttributePath &
 
     if (clusterId == DoorLock::Id && attributeId == DoorLock::Attributes::LockState::Id)
     {
-        ChipLogProgress(Zcl, "Door lock cluster: " ChipLogFormatMEI, ChipLogValueMEI(clusterId));
+        DoorLock::DlLockState lockState = *(reinterpret_cast<DoorLock::DlLockState *>(value));
+        ChipLogProgress(Zcl, "Door lock cluster: " ChipLogFormatMEI " state %d", ChipLogValueMEI(clusterId),
+                        to_underlying(lockState));
     }
 }
 
@@ -146,3 +148,9 @@ DlStatus emberAfPluginDoorLockSetSchedule(chip::EndpointId endpointId, uint8_t h
 {
     return LockMgr().SetHolidaySchedule(endpointId, holidayIndex, status, localStartTime, localEndTime, operatingMode);
 }
+
+void emberAfPluginDoorLockOnAutoRelock(chip::EndpointId endpointId)
+{
+    // Apply the relock state in the application control
+    LockMgr().InitiateAction(AppEvent::kEventType_Lock, LockManager::LOCK_ACTION);
+}
diff --git a/examples/platform/efr32/EFR32DeviceAttestationCreds.cpp b/examples/platform/efr32/EFR32DeviceAttestationCreds.cpp
index 942505bd82e81c..f68f0b892be1d6 100644
--- a/examples/platform/efr32/EFR32DeviceAttestationCreds.cpp
+++ b/examples/platform/efr32/EFR32DeviceAttestationCreds.cpp
@@ -23,7 +23,7 @@
 #include "efr32_creds.h"
 #include "psa/crypto.h"
 
-extern uint32_t __attestation_credentials_base;
+extern uint8_t __attestation_credentials_base[];
 
 namespace chip {
 namespace Credentials {
@@ -37,7 +37,7 @@ class DeviceAttestationCredsEFR32 : public DeviceAttestationCredentialsProvider
 public:
     CHIP_ERROR GetCertificationDeclaration(MutableByteSpan & out_buffer) override
     {
-        ByteSpan cd_span(((uint8_t *) &__attestation_credentials_base) + EFR32_CREDENTIALS_CD_OFFSET, EFR32_CREDENTIALS_CD_SIZE);
+        ByteSpan cd_span(((uint8_t *) __attestation_credentials_base) + EFR32_CREDENTIALS_CD_OFFSET, EFR32_CREDENTIALS_CD_SIZE);
         return CopySpanToMutableSpan(cd_span, out_buffer);
     }
 
@@ -50,15 +50,13 @@ class DeviceAttestationCredsEFR32 : public DeviceAttestationCredentialsProvider
 
     CHIP_ERROR GetDeviceAttestationCert(MutableByteSpan & out_buffer) override
     {
-        ByteSpan cert_span(((uint8_t *) &__attestation_credentials_base) + EFR32_CREDENTIALS_DAC_OFFSET,
-                           EFR32_CREDENTIALS_DAC_SIZE);
+        ByteSpan cert_span(((uint8_t *) __attestation_credentials_base) + EFR32_CREDENTIALS_DAC_OFFSET, EFR32_CREDENTIALS_DAC_SIZE);
         return CopySpanToMutableSpan(cert_span, out_buffer);
     }
 
     CHIP_ERROR GetProductAttestationIntermediateCert(MutableByteSpan & out_pai_buffer) override
     {
-        ByteSpan cert_span(((uint8_t *) &__attestation_credentials_base) + EFR32_CREDENTIALS_PAI_OFFSET,
-                           EFR32_CREDENTIALS_PAI_SIZE);
+        ByteSpan cert_span(((uint8_t *) __attestation_credentials_base) + EFR32_CREDENTIALS_PAI_OFFSET, EFR32_CREDENTIALS_PAI_SIZE);
         return CopySpanToMutableSpan(cert_span, out_pai_buffer);
     }
 
diff --git a/examples/platform/efr32/rs911x/rsi_if.c b/examples/platform/efr32/rs911x/rsi_if.c
index 872d82c411269b..ad72f6361c055c 100644
--- a/examples/platform/efr32/rs911x/rsi_if.c
+++ b/examples/platform/efr32/rs911x/rsi_if.c
@@ -738,6 +738,7 @@ void wfx_rsi_task(void * arg)
     }
 }
 
+#if CHIP_DEVICE_CONFIG_ENABLE_IPV4
 /********************************************************************************************
  * @fn   void wfx_dhcp_got_ipv4(uint32_t ip)
  * @brief
@@ -761,6 +762,7 @@ void wfx_dhcp_got_ipv4(uint32_t ip)
     wfx_ip_changed_notify(IP_STATUS_SUCCESS);
     wfx_rsi.dev_state |= WFX_RSI_ST_STA_READY;
 }
+#endif /* CHIP_DEVICE_CONFIG_ENABLE_IPV4 */
 
 /*
  * WARNING - Taken from RSI and broken up
diff --git a/examples/platform/efr32/rs911x/wfx_rsi.h b/examples/platform/efr32/rs911x/wfx_rsi.h
index 5899a0c45bc31e..380fc8f29e1693 100644
--- a/examples/platform/efr32/rs911x/wfx_rsi.h
+++ b/examples/platform/efr32/rs911x/wfx_rsi.h
@@ -82,7 +82,9 @@ extern "C" {
 void wfx_rsidev_init(void);
 void wfx_rsi_task(void * arg);
 void efr32Log(const char * aFormat, ...);
+#if CHIP_DEVICE_CONFIG_ENABLE_IPV4
 void wfx_ip_changed_notify(int got_ip);
+#endif /* CHIP_DEVICE_CONFIG_ENABLE_IPV4 */
 int32_t wfx_rsi_get_ap_info(wfx_wifi_scan_result_t * ap);
 int32_t wfx_rsi_get_ap_ext(wfx_wifi_scan_ext_t * extra_info);
 int32_t wfx_rsi_reset_count();
diff --git a/examples/platform/efr32/rs911x/wfx_rsi_host.c b/examples/platform/efr32/rs911x/wfx_rsi_host.c
index 2a502356e6ae66..a55e0aeb5cab2e 100644
--- a/examples/platform/efr32/rs911x/wfx_rsi_host.c
+++ b/examples/platform/efr32/rs911x/wfx_rsi_host.c
@@ -294,7 +294,7 @@ sl_status_t wfx_sta_discon(void)
     WFX_RSI_LOG("%s: completed.", __func__);
     return status;
 }
-
+#if CHIP_DEVICE_CONFIG_ENABLE_IPV4
 /*********************************************************************
  * @fn  bool wfx_have_ipv4_addr(sl_wfx_interface_t which_if)
  * @brief
@@ -317,6 +317,7 @@ bool wfx_have_ipv4_addr(sl_wfx_interface_t which_if)
     WFX_RSI_LOG("%s: status: %d", __func__, status);
     return status;
 }
+#endif /* CHIP_DEVICE_CONFIG_ENABLE_IPV4 */
 
 /*********************************************************************
  * @fn  bool wfx_have_ipv6_addr(sl_wfx_interface_t which_if)
diff --git a/examples/platform/efr32/wf200/host_if.cpp b/examples/platform/efr32/wf200/host_if.cpp
index 8015a0cb7a1caa..d6f90419613f22 100644
--- a/examples/platform/efr32/wf200/host_if.cpp
+++ b/examples/platform/efr32/wf200/host_if.cpp
@@ -1132,6 +1132,7 @@ static void sl_wfx_ap_client_rejected_callback(uint32_t status, uint8_t * mac)
      ******************************************************************************/
     bool wfx_hw_ready(void) { return (wifiContext.state & SL_WFX_STARTED) ? true : false; }
 
+#if CHIP_DEVICE_CONFIG_ENABLE_IPV4
     /*****************************************************************************
      * @fn  void wfx_dhcp_got_ipv4(uint32_t ip)
      * @brief
@@ -1146,6 +1147,7 @@ static void sl_wfx_ap_client_rejected_callback(uint32_t status, uint8_t * mac)
         sta_ip = ip;
         wfx_ip_changed_notify(IP_STATUS_SUCCESS);
     }
+#endif /* CHIP_DEVICE_CONFIG_ENABLE_IPV4 */
 
     /*****************************************************************************
      * @fn  wfx_enable_sta_mode(void)
diff --git a/examples/thermostat/efr32/BUILD.gn b/examples/thermostat/efr32/BUILD.gn
index 9c74f3224df18f..da732a26122b1d 100644
--- a/examples/thermostat/efr32/BUILD.gn
+++ b/examples/thermostat/efr32/BUILD.gn
@@ -76,6 +76,7 @@ assert(!(use_wf200 && chip_enable_openthread))
 if (chip_enable_wifi) {
   assert(use_rs911x || use_wf200)
   enable_openthread_cli = false
+  import("${chip_root}/src/platform/EFR32/wifi_args.gni")
 }
 
 # ThunderBoards, Explorer Kit and MGM240L do not support LCD (No LCD)
@@ -89,14 +90,28 @@ if (silabs_board == "BRD4166A" || silabs_board == "BRD2601B" ||
 if (chip_enable_wifi) {
   wifi_sdk_dir = "${chip_root}/src/platform/EFR32/wifi"
   efr32_lwip_defs = [ "LWIP_NETIF_API=1" ]
-  efr32_lwip_defs += [
-    "LWIP_IPV4=1",
-    "LWIP_ARP=1",
-    "LWIP_ICMP=1",
-    "LWIP_DHCP=1",
-    "LWIP_IPV6_ND=1",
-    "LWIP_IGMP=1",
-  ]
+  if (lwip_ipv4) {
+    efr32_lwip_defs += [
+      "LWIP_IPV4=1",
+
+      # adds following options to provide
+      # them to .cpp source files
+      # flags ported from lwipopts file
+      # TODO: move lwipopts to one location
+      "LWIP_ARP=1",
+      "LWIP_ICMP=1",
+      "LWIP_IGMP=1",
+      "LWIP_DHCP=1",
+      "LWIP_DNS=0",
+    ]
+  } else {
+    efr32_lwip_defs += [ "LWIP_IPV4=0" ]
+  }
+  if (lwip_ipv6) {
+    efr32_lwip_defs += [ "LWIP_IPV6=1" ]
+  } else {
+    efr32_lwip_defs += [ "LWIP_IPV6=0" ]
+  }
 
   if (use_rs911x) {
     wiseconnect_sdk_root =
diff --git a/examples/tv-casting-app/android/App/app/src/main/java/com/chip/casting/app/MainActivity.java b/examples/tv-casting-app/android/App/app/src/main/java/com/chip/casting/app/MainActivity.java
index d2a4327685b832..85812285fe581e 100644
--- a/examples/tv-casting-app/android/App/app/src/main/java/com/chip/casting/app/MainActivity.java
+++ b/examples/tv-casting-app/android/App/app/src/main/java/com/chip/casting/app/MainActivity.java
@@ -53,7 +53,7 @@ public void handleCommissioningButtonClicked(DiscoveredNodeData commissioner) {
 
   @Override
   public void handleCommissioningComplete() {
-    showFragment(SelectClusterFragment.newInstance());
+    showFragment(SelectClusterFragment.newInstance(tvCastingApp));
   }
 
   @Override
@@ -66,6 +66,11 @@ public void handleMediaPlaybackSelected() {
     showFragment(MediaPlaybackFragment.newInstance(tvCastingApp));
   }
 
+  @Override
+  public void handleDisconnect() {
+    showFragment(CommissionerDiscoveryFragment.newInstance(tvCastingApp));
+  }
+
   /**
    * The order is important, must first new TvCastingApp to load dynamic library, then
    * AndroidChipPlatform to prepare platform, then start ChipAppServer, then call init on
diff --git a/examples/tv-casting-app/android/App/app/src/main/java/com/chip/casting/app/MediaPlaybackFragment.java b/examples/tv-casting-app/android/App/app/src/main/java/com/chip/casting/app/MediaPlaybackFragment.java
index ad0df7878dc63c..7e9070665b74b4 100644
--- a/examples/tv-casting-app/android/App/app/src/main/java/com/chip/casting/app/MediaPlaybackFragment.java
+++ b/examples/tv-casting-app/android/App/app/src/main/java/com/chip/casting/app/MediaPlaybackFragment.java
@@ -24,6 +24,8 @@ public class MediaPlaybackFragment extends Fragment {
 
   private View.OnClickListener subscribeToCurrentStateButtonClickListener;
 
+  private View.OnClickListener shutdownALlSubscriptionsButtonClickListener;
+
   private static final ContentApp kContentApp = new ContentApp((short) 4, null);
 
   public MediaPlaybackFragment(TvCastingApp tvCastingApp) {
@@ -123,6 +125,15 @@ public void run() {
           }
         };
 
+    this.shutdownALlSubscriptionsButtonClickListener =
+        new View.OnClickListener() {
+          @Override
+          public void onClick(View v) {
+            Log.d(TAG, "Shutting down all subscriptions");
+            tvCastingApp.shutdownAllSubscriptions();
+          }
+        };
+
     return inflater.inflate(R.layout.fragment_media_playback, container, false);
   }
 
@@ -133,5 +144,9 @@ public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
     getView()
         .findViewById(R.id.subscribeToCurrentStateButton)
         .setOnClickListener(subscribeToCurrentStateButtonClickListener);
+
+    getView()
+        .findViewById(R.id.shutdownAllSubscriptionsButton)
+        .setOnClickListener(shutdownALlSubscriptionsButtonClickListener);
   }
 }
diff --git a/examples/tv-casting-app/android/App/app/src/main/java/com/chip/casting/app/SelectClusterFragment.java b/examples/tv-casting-app/android/App/app/src/main/java/com/chip/casting/app/SelectClusterFragment.java
index 67de30838b296d..f80f286ea3df22 100644
--- a/examples/tv-casting-app/android/App/app/src/main/java/com/chip/casting/app/SelectClusterFragment.java
+++ b/examples/tv-casting-app/android/App/app/src/main/java/com/chip/casting/app/SelectClusterFragment.java
@@ -7,22 +7,31 @@
 import android.view.ViewGroup;
 import androidx.annotation.Nullable;
 import androidx.fragment.app.Fragment;
+import com.chip.casting.TvCastingApp;
 
 /** An interstitial {@link Fragment} to select one of the supported media actions to perform */
 public class SelectClusterFragment extends Fragment {
   private static final String TAG = SelectClusterFragment.class.getSimpleName();
 
+  private final TvCastingApp tvCastingApp;
+
   private View.OnClickListener selectContentLauncherButtonClickListener;
   private View.OnClickListener selectMediaPlaybackButtonClickListener;
+  private View.OnClickListener disconnectButtonClickListener;
+
+  public SelectClusterFragment(TvCastingApp tvCastingApp) {
+    this.tvCastingApp = tvCastingApp;
+  }
 
   /**
    * Use this factory method to create a new instance of this fragment using the provided
    * parameters.
    *
+   * @param tvCastingApp TV Casting App (JNI)
    * @return A new instance of fragment SelectActionFragment.
    */
-  public static SelectClusterFragment newInstance() {
-    return new SelectClusterFragment();
+  public static SelectClusterFragment newInstance(TvCastingApp tvCastingApp) {
+    return new SelectClusterFragment(tvCastingApp);
   }
 
   @Override
@@ -52,6 +61,16 @@ public void onClick(View v) {
           }
         };
 
+    this.disconnectButtonClickListener =
+        new View.OnClickListener() {
+          @Override
+          public void onClick(View v) {
+            Log.d(TAG, "Disconnecting from current video player");
+            tvCastingApp.disconnect();
+            callback.handleDisconnect();
+          }
+        };
+
     return inflater.inflate(R.layout.fragment_select_cluster, container, false);
   }
 
@@ -65,6 +84,7 @@ public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
     getView()
         .findViewById(R.id.selectMediaPlaybackButton)
         .setOnClickListener(selectMediaPlaybackButtonClickListener);
+    getView().findViewById(R.id.disconnectButton).setOnClickListener(disconnectButtonClickListener);
   }
 
   /** Interface for notifying the host. */
@@ -74,5 +94,8 @@ public interface Callback {
 
     /** Notifies listener to trigger transition on selection of Media Playback cluster */
     void handleMediaPlaybackSelected();
+
+    /** Notifies listener to trigger transition on click of the Disconnect button */
+    void handleDisconnect();
   }
 }
diff --git a/examples/tv-casting-app/android/App/app/src/main/jni/com/chip/casting/TvCastingApp.java b/examples/tv-casting-app/android/App/app/src/main/jni/com/chip/casting/TvCastingApp.java
index 20235ae21b38e2..65cd2cbcec1902 100644
--- a/examples/tv-casting-app/android/App/app/src/main/jni/com/chip/casting/TvCastingApp.java
+++ b/examples/tv-casting-app/android/App/app/src/main/jni/com/chip/casting/TvCastingApp.java
@@ -95,6 +95,10 @@ public native boolean verifyOrEstablishConnection(
       FailureCallback onConnectionFailure,
       SuccessCallback<ContentApp> onNewOrUpdatedEndpointCallback);
 
+  public native void shutdownAllSubscriptions();
+
+  public native void disconnect();
+
   public native List<VideoPlayer> getActiveTargetVideoPlayers();
 
   /*
@@ -328,7 +332,7 @@ public native boolean applicationBasic_readVendorName(
 
   public native boolean applicationBasic_readVendorID(
       ContentApp contentApp,
-      SuccessCallback<Short> readSuccessHandler,
+      SuccessCallback<Integer> readSuccessHandler,
       FailureCallback readFailureHandler);
 
   public native boolean applicationBasic_readApplicationName(
@@ -338,7 +342,7 @@ public native boolean applicationBasic_readApplicationName(
 
   public native boolean applicationBasic_readProductID(
       ContentApp contentApp,
-      SuccessCallback<Short> readSuccessHandler,
+      SuccessCallback<Integer> readSuccessHandler,
       FailureCallback readFailureHandler);
 
   public native boolean applicationBasic_readApplicationVersion(
diff --git a/examples/tv-casting-app/android/App/app/src/main/jni/cpp/MatterCallbackHandler-JNI.cpp b/examples/tv-casting-app/android/App/app/src/main/jni/cpp/MatterCallbackHandler-JNI.cpp
index 862334ae1ee4cb..2d78fe461a6c2e 100644
--- a/examples/tv-casting-app/android/App/app/src/main/jni/cpp/MatterCallbackHandler-JNI.cpp
+++ b/examples/tv-casting-app/android/App/app/src/main/jni/cpp/MatterCallbackHandler-JNI.cpp
@@ -34,7 +34,7 @@ CHIP_ERROR CallbackBaseJNI::SetUp(JNIEnv * env, jobject inHandler)
     mMethod = env->GetMethodID(mClazz, "handle", mMethodSignature);
     if (mMethod == nullptr)
     {
-        ChipLogError(AppServer, "Failed to access 'handle' method");
+        ChipLogError(AppServer, "Failed to access 'handle' method with signature %s", mMethodSignature);
         env->ExceptionClear();
     }
 
@@ -50,7 +50,7 @@ CHIP_ERROR CallbackBaseJNI::SetUp(JNIEnv * env, jobject inHandler)
 
 void FailureHandlerJNI::Handle(CHIP_ERROR callbackErr)
 {
-    ChipLogProgress(AppServer, "FailureHandlerJNI::Handle called");
+    ChipLogProgress(AppServer, "Handle(CHIP_ERROR) called");
 
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     UtfString jniCallbackErrString(env, callbackErr.AsString());
@@ -63,7 +63,7 @@ void FailureHandlerJNI::Handle(CHIP_ERROR callbackErr)
 exit:
     if (err != CHIP_NO_ERROR)
     {
-        ChipLogError(AppServer, "FailureHandlerJNI::Handle status error: %s", err.AsString());
+        ChipLogError(AppServer, "Handle(CHIP_ERROR) status error: %s", err.AsString());
     }
 }
 
@@ -332,9 +332,10 @@ jobject TargetListSuccessHandlerJNI::ConvertToJObject(
             return nullptr;
         }
 
-        jmethodID constructor = env->GetMethodID(responseTypeClass, "<init>", "(Ljava/lang/Integer;java/lang/String;)V");
+        jmethodID constructor = env->GetMethodID(responseTypeClass, "<init>", "(Ljava/lang/Integer;Ljava/lang/String;)V");
         chip::UtfString targetInfoName(env, targetInfo.name);
-        jobject jTargetInfo = env->NewObject(responseTypeClass, constructor, targetInfo.identifier, targetInfoName.jniValue());
+        jobject jTargetInfo = env->NewObject(responseTypeClass, constructor, ConvertToIntegerJObject(targetInfo.identifier),
+                                             targetInfoName.jniValue());
 
         chip::JniReferences::GetInstance().AddToList(jArrayList, jTargetInfo);
     }
diff --git a/examples/tv-casting-app/android/App/app/src/main/jni/cpp/TvCastingApp-JNI.cpp b/examples/tv-casting-app/android/App/app/src/main/jni/cpp/TvCastingApp-JNI.cpp
index 33d7c753bf9042..04c1196fcd57fe 100644
--- a/examples/tv-casting-app/android/App/app/src/main/jni/cpp/TvCastingApp-JNI.cpp
+++ b/examples/tv-casting-app/android/App/app/src/main/jni/cpp/TvCastingApp-JNI.cpp
@@ -204,6 +204,21 @@ JNI_METHOD(jboolean, verifyOrEstablishConnection)
     return true;
 }
 
+JNI_METHOD(void, shutdownAllSubscriptions)(JNIEnv * env, jobject)
+{
+    chip::DeviceLayer::StackLock lock;
+    ChipLogProgress(AppServer, "JNI_METHOD shutdownAllSubscriptions called");
+
+    CastingServer::GetInstance()->ShutdownAllSubscriptions();
+}
+
+JNI_METHOD(void, disconnect)(JNIEnv * env, jobject)
+{
+    chip::DeviceLayer::StackLock lock;
+    ChipLogProgress(AppServer, "JNI_METHOD disconnect called");
+    CastingServer::GetInstance()->Disconnect();
+}
+
 JNI_METHOD(jobject, getActiveTargetVideoPlayers)(JNIEnv * env, jobject)
 {
     chip::DeviceLayer::StackLock lock;
diff --git a/examples/tv-casting-app/android/App/app/src/main/res/layout/fragment_media_playback.xml b/examples/tv-casting-app/android/App/app/src/main/res/layout/fragment_media_playback.xml
index fac656c8c447a5..4aea6b35967ed5 100644
--- a/examples/tv-casting-app/android/App/app/src/main/res/layout/fragment_media_playback.xml
+++ b/examples/tv-casting-app/android/App/app/src/main/res/layout/fragment_media_playback.xml
@@ -102,5 +102,19 @@
                 android:layout_height="wrap_content"
                 android:textAppearance="@style/TextAppearance.AppCompat.Large" />
         </LinearLayout>
+
+        <LinearLayout
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal" >
+            <Button
+                android:id="@+id/shutdownAllSubscriptionsButton"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="@string/shutdown_all_subscriptions_button_text"
+                android:textAppearance="@style/TextAppearance.AppCompat.Body1"
+                android:layout_marginRight="10sp" />
+        </LinearLayout>
+
     </LinearLayout>
 </FrameLayout>
\ No newline at end of file
diff --git a/examples/tv-casting-app/android/App/app/src/main/res/layout/fragment_select_cluster.xml b/examples/tv-casting-app/android/App/app/src/main/res/layout/fragment_select_cluster.xml
index c79e3d31f05fc9..1eee44c232346f 100644
--- a/examples/tv-casting-app/android/App/app/src/main/res/layout/fragment_select_cluster.xml
+++ b/examples/tv-casting-app/android/App/app/src/main/res/layout/fragment_select_cluster.xml
@@ -5,13 +5,14 @@
     android:layout_height="match_parent"
     tools:context=".SelectClusterFragment">
 
-    <LinearLayout
+    <RelativeLayout
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:orientation="vertical"
         android:padding="10sp">
 
         <TextView
+            android:id="@+id/select_cluster_heading"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:text="@string/select_cluster_text"
@@ -23,7 +24,8 @@
             android:layout_height="wrap_content"
             android:text="@string/select_content_launcher_button_text"
             android:textAppearance="@style/TextAppearance.AppCompat.Body1"
-            android:layout_marginRight="10sp" />
+            android:layout_marginRight="10sp"
+            android:layout_below="@id/select_cluster_heading" />
 
         <Button
             android:id="@+id/selectMediaPlaybackButton"
@@ -31,6 +33,16 @@
             android:layout_height="wrap_content"
             android:text="@string/select_media_playback_button_text"
             android:textAppearance="@style/TextAppearance.AppCompat.Body1"
-            android:layout_marginRight="10sp" />
-    </LinearLayout>
+            android:layout_marginRight="10sp"
+            android:layout_below="@id/selectContentLauncherButton"/>
+
+        <Button
+            android:id="@+id/disconnectButton"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="@string/disconnect_button_text"
+            android:textAppearance="@style/TextAppearance.AppCompat.Body1"
+            android:layout_marginRight="10sp"
+            android:layout_alignParentBottom="true" />
+    </RelativeLayout>
 </FrameLayout>
\ No newline at end of file
diff --git a/examples/tv-casting-app/android/App/app/src/main/res/values/strings.xml b/examples/tv-casting-app/android/App/app/src/main/res/values/strings.xml
index 16900225b2e0cc..80b064f6532a07 100644
--- a/examples/tv-casting-app/android/App/app/src/main/res/values/strings.xml
+++ b/examples/tv-casting-app/android/App/app/src/main/res/values/strings.xml
@@ -20,4 +20,6 @@
     <string name="subscribe_to_current_state_button_text">Subscribe</string>
     <string name="current_state_text">Reported Current State</string>
     <string name="endpoint_prompt_text">Endpoint ID</string>
+    <string name="shutdown_all_subscriptions_button_text">Shutdown all Subscriptions</string>
+    <string name="disconnect_button_text">Disconnect from Video Player</string>
 </resources>
\ No newline at end of file
diff --git a/examples/tv-casting-app/darwin/MatterTvCastingBridge/MatterTvCastingBridge/CastingServerBridge.h b/examples/tv-casting-app/darwin/MatterTvCastingBridge/MatterTvCastingBridge/CastingServerBridge.h
index b91f930f5327a7..08383339df0d6a 100644
--- a/examples/tv-casting-app/darwin/MatterTvCastingBridge/MatterTvCastingBridge/CastingServerBridge.h
+++ b/examples/tv-casting-app/darwin/MatterTvCastingBridge/MatterTvCastingBridge/CastingServerBridge.h
@@ -166,6 +166,24 @@
         onConnectionFailureCallback:(void (^_Nonnull)(MatterError * _Nonnull))onConnectionFailureCallback
      onNewOrUpdatedEndpointCallback:(void (^_Nonnull)(ContentApp * _Nonnull))onNewOrUpdatedEndpointCallback;
 
+/*!
+ @brief Tears down all active subscriptions.
+
+ @param clientQueue Queue to invoke callbacks on
+
+ @param requestSentHandler Called after the request has been sent
+ */
+- (void)shutdownAllSubscriptions:(dispatch_queue_t _Nonnull)clientQueue requestSentHandler:(nullable void (^)())requestSentHandler;
+
+/*!
+ @brief  Mark any open session with the currently connected Video player as expired.
+
+ @param clientQueue Queue to invoke callbacks on
+
+ @param requestSentHandler Called after the request has been sent
+ */
+- (void)disconnect:(dispatch_queue_t _Nonnull)clientQueue requestSentHandler:(nullable void (^)())requestSentHandler;
+
 /*!
  @brief Send a ContentLauncher:LaunchURL request to a TV
 
diff --git a/examples/tv-casting-app/darwin/MatterTvCastingBridge/MatterTvCastingBridge/CastingServerBridge.mm b/examples/tv-casting-app/darwin/MatterTvCastingBridge/MatterTvCastingBridge/CastingServerBridge.mm
index c4ffd87f2a09d8..d9e36da0211121 100644
--- a/examples/tv-casting-app/darwin/MatterTvCastingBridge/MatterTvCastingBridge/CastingServerBridge.mm
+++ b/examples/tv-casting-app/darwin/MatterTvCastingBridge/MatterTvCastingBridge/CastingServerBridge.mm
@@ -402,6 +402,28 @@ - (void)verifyOrEstablishConnection:(VideoPlayer * _Nonnull)videoPlayer
     });
 }
 
+- (void)shutdownAllSubscriptions:(dispatch_queue_t _Nonnull)clientQueue requestSentHandler:(nullable void (^)())requestSentHandler
+{
+    ChipLogProgress(AppServer, "CastingServerBridge().shutdownAllSubscriptions() called");
+    dispatch_async(_chipWorkQueue, ^{
+        CastingServer::GetInstance()->ShutdownAllSubscriptions();
+        dispatch_async(clientQueue, ^{
+            requestSentHandler();
+        });
+    });
+}
+
+- (void)disconnect:(dispatch_queue_t _Nonnull)clientQueue requestSentHandler:(nullable void (^)())requestSentHandler
+{
+    ChipLogProgress(AppServer, "CastingServerBridge().disconnect() called");
+    dispatch_async(_chipWorkQueue, ^{
+        CastingServer::GetInstance()->Disconnect();
+        dispatch_async(clientQueue, ^{
+            requestSentHandler();
+        });
+    });
+}
+
 - (void)contentLauncher_launchUrl:(ContentApp * _Nonnull)contentApp
                        contentUrl:(NSString * _Nonnull)contentUrl
                 contentDisplayStr:(NSString * _Nonnull)contentDisplayStr
diff --git a/examples/tv-casting-app/tv-casting-common/include/CastingServer.h b/examples/tv-casting-app/tv-casting-common/include/CastingServer.h
index 375ede1f6b8af3..09fb76d21525df 100644
--- a/examples/tv-casting-app/tv-casting-common/include/CastingServer.h
+++ b/examples/tv-casting-app/tv-casting-common/include/CastingServer.h
@@ -96,6 +96,16 @@ class CastingServer
 
     CHIP_ERROR PurgeVideoPlayerCache();
 
+    /**
+     * Tears down all active subscriptions.
+     */
+    void ShutdownAllSubscriptions();
+
+    /**
+     *  Mark any open session with the currently connected Video player as expired.
+     */
+    void Disconnect();
+
     /**
      * @brief Content Launcher cluster
      */
diff --git a/examples/tv-casting-app/tv-casting-common/src/CastingServer.cpp b/examples/tv-casting-app/tv-casting-common/src/CastingServer.cpp
index 505f578086dd71..1fa2965abcbff6 100644
--- a/examples/tv-casting-app/tv-casting-common/src/CastingServer.cpp
+++ b/examples/tv-casting-app/tv-casting-common/src/CastingServer.cpp
@@ -424,6 +424,28 @@ void CastingServer::SetDefaultFabricIndex(std::function<void(TargetVideoPlayerIn
     ChipLogError(AppServer, " -- No initialized fabrics with video players");
 }
 
+void CastingServer::ShutdownAllSubscriptions()
+{
+    ChipLogProgress(AppServer, "Shutting down ALL Subscriptions");
+    app::InteractionModelEngine::GetInstance()->ShutdownAllSubscriptions();
+}
+
+void CastingServer::Disconnect()
+{
+    TargetVideoPlayerInfo * currentVideoPlayer = GetActiveTargetVideoPlayer();
+
+    if (currentVideoPlayer != nullptr && currentVideoPlayer->IsInitialized())
+    {
+        chip::OperationalDeviceProxy * operationalDeviceProxy = currentVideoPlayer->GetOperationalDeviceProxy();
+        if (operationalDeviceProxy != nullptr)
+        {
+            ChipLogProgress(AppServer, "Disconnecting from VideoPlayer with nodeId=0x" ChipLogFormatX64 " fabricIndex=%d",
+                            ChipLogValueX64(currentVideoPlayer->GetNodeId()), currentVideoPlayer->GetFabricIndex());
+            operationalDeviceProxy->Disconnect();
+        }
+    }
+}
+
 /**
  * @brief Content Launcher cluster
  */
diff --git a/examples/window-app/efr32/BUILD.gn b/examples/window-app/efr32/BUILD.gn
index 8a62fa7f9cb069..c94685c6279da5 100644
--- a/examples/window-app/efr32/BUILD.gn
+++ b/examples/window-app/efr32/BUILD.gn
@@ -73,6 +73,7 @@ assert(!(use_wf200 && chip_enable_openthread))
 if (chip_enable_wifi) {
   assert(use_rs911x || use_wf200)
   enable_openthread_cli = false
+  import("${chip_root}/src/platform/EFR32/wifi_args.gni")
 }
 
 # ThunderBoards, Explorer Kit and MGM240L do not support LCD (No LCD)
@@ -91,14 +92,28 @@ if (chip_enable_wifi) {
   }
   wifi_sdk_dir = "${chip_root}/src/platform/EFR32/wifi"
   efr32_lwip_defs = [ "LWIP_NETIF_API=1" ]
-  efr32_lwip_defs += [
-    "LWIP_IPV4=1",
-    "LWIP_ARP=1",
-    "LWIP_ICMP=1",
-    "LWIP_DHCP=1",
-    "LWIP_IPV6_ND=1",
-    "LWIP_IGMP=1",
-  ]
+  if (lwip_ipv4) {
+    efr32_lwip_defs += [
+      "LWIP_IPV4=1",
+
+      # adds following options to provide
+      # them to .cpp source files
+      # flags ported from lwipopts file
+      # TODO: move lwipopts to one location
+      "LWIP_ARP=1",
+      "LWIP_ICMP=1",
+      "LWIP_IGMP=1",
+      "LWIP_DHCP=1",
+      "LWIP_DNS=0",
+    ]
+  } else {
+    efr32_lwip_defs += [ "LWIP_IPV4=0" ]
+  }
+  if (lwip_ipv6) {
+    efr32_lwip_defs += [ "LWIP_IPV6=1" ]
+  } else {
+    efr32_lwip_defs += [ "LWIP_IPV6=0" ]
+  }
 
   if (use_rs911x) {
     wiseconnect_sdk_root =
diff --git a/integrations/docker/ci-only-images/chip-cirque-device-base/Dockerfile b/integrations/docker/ci-only-images/chip-cirque-device-base/Dockerfile
index 3fe1dfe7e7b3d4..465723a5dda193 100644
--- a/integrations/docker/ci-only-images/chip-cirque-device-base/Dockerfile
+++ b/integrations/docker/ci-only-images/chip-cirque-device-base/Dockerfile
@@ -16,27 +16,27 @@ RUN apt-cache policy
 # TODO: Use multi stage build for smaller image size.
 RUN apt-get update \
   && apt-get install --no-install-recommends -y \
-  avahi-daemon=0.7-4ubuntu7.1 \
-  avahi-utils=0.7-4ubuntu7.1 \
-  ca-certificates=20211016~20.04.1 \
-  dhcpcd5=7.1.0-2build1 \
-  gdb=9.2-0ubuntu1~20.04.1 \
+  avahi-daemon \
+  avahi-utils \
+  ca-certificates \
+  dhcpcd5 \
+  gdb \
   git \
-  iproute2=5.5.0-1ubuntu1 \
-  libavahi-client3=0.7-4ubuntu7.1 \
-  libcairo2-dev=1.16.0-4ubuntu1 \
-  libdbus-1-dev=1.12.16-2ubuntu2.2 \
-  libgif-dev=5.1.9-1 \
-  libgirepository1.0-dev=1.64.1-1~ubuntu20.04.1 \
-  libglib2.0-dev=2.64.6-1~ubuntu20.04.4 \
-  libjpeg-dev=8c-2ubuntu8 \
-  psmisc=23.3-1 \
-  python3-dev=3.8.2-0ubuntu2 \
-  python3-pip=20.0.2-5ubuntu1.6 \
-  python3=3.8.2-0ubuntu2 \
-  sudo=1.8.31-1ubuntu1.2 \
-  wireless-tools=30~pre9-13ubuntu1 \
-  wpasupplicant=2:2.9-1ubuntu4.3 \
+  iproute2 \
+  libavahi-client3 \
+  libcairo2-dev \
+  libdbus-1-dev \
+  libgif-dev \
+  libgirepository1.0-dev \
+  libglib2.0-dev \
+  libjpeg-dev \
+  psmisc \
+  python3-dev \
+  python3-pip \
+  python3 \
+  sudo \
+  wireless-tools \
+  wpasupplicant \
   && ln -fs /usr/share/zoneinfo/UTC /etc/localtime \
   && git clone https://github.com/openthread/ot-br-posix . \
   && git checkout $OT_BR_POSIX_CHECKOUT \
diff --git a/scripts/tools/nrfconnect/generate_nrfconnect_chip_factory_data.py b/scripts/tools/nrfconnect/generate_nrfconnect_chip_factory_data.py
index f4e9a2b2bfb014..02ebc6de0a650f 100644
--- a/scripts/tools/nrfconnect/generate_nrfconnect_chip_factory_data.py
+++ b/scripts/tools/nrfconnect/generate_nrfconnect_chip_factory_data.py
@@ -301,6 +301,8 @@ def generate_json(self):
             self._add_entry("product_id", self._args.product_id)
             self._add_entry("vendor_name", self._args.vendor_name)
             self._add_entry("product_name", self._args.product_name)
+            self._add_entry("product_label", self._args.product_label)
+            self._add_entry("part_number", self._args.part_number)
             self._add_entry("date", self._args.date)
             self._add_entry("hw_ver", self._args.hw_ver)
             self._add_entry("hw_ver_str", self._args.hw_ver_str)
@@ -438,6 +440,10 @@ def base64_str(s): return base64.b64decode(s)
                                      the setup code. Discriminator is used during a discovery process.")
 
     # optional keys
+    optional_arguments.add_argument("--product_label", type=str,
+                                    help="[string] provide human-readable product label")
+    optional_arguments.add_argument("--part_number", type=str,
+                                    help="[string] provide human-readable product number")
     optional_arguments.add_argument("--chip_cert_path", type=str,
                                     help="Generate DAC and PAI certificates instead giving a path to .der files. This option requires a path to chip-cert executable."
                                     "By default You can find spake2p in connectedhomeip/src/tools/chip-cert directory and build it there.")
diff --git a/scripts/tools/nrfconnect/nrfconnect_factory_data.schema b/scripts/tools/nrfconnect/nrfconnect_factory_data.schema
index fa2e9a2679d6cc..73f3ddc4609daf 100644
--- a/scripts/tools/nrfconnect/nrfconnect_factory_data.schema
+++ b/scripts/tools/nrfconnect/nrfconnect_factory_data.schema
@@ -55,6 +55,16 @@
             "type": "string",
             "maxLength": 32
         },
+        "product_label": {
+            "description": "more user-friendly human-readable product name",
+            "type": "string",
+            "maxLength": 64
+        },
+        "part_number": {
+            "description": "human-readable vendor assigned part number",
+            "type": "string",
+            "maxLength": 32
+        },
         "date": {
             "description": "Manufacturing date according to ISO 8601 in notation YYYY-MM-DD",
             "type": "string",
@@ -144,4 +154,4 @@
             "type": "object"
         }
     }
-}
\ No newline at end of file
+}
diff --git a/scripts/tools/nrfconnect/tests/test_generate_factory_data.py b/scripts/tools/nrfconnect/tests/test_generate_factory_data.py
index 8b45a0e81556ac..dc588959c680e9 100755
--- a/scripts/tools/nrfconnect/tests/test_generate_factory_data.py
+++ b/scripts/tools/nrfconnect/tests/test_generate_factory_data.py
@@ -153,7 +153,9 @@ def test_generate_factory_data_all_specified(self):
                                    '--vendor_id', '0x127F',
                                    '--product_id', '0xABCD',
                                    '--vendor_name', 'Nordic Semiconductor ASA',
-                                   '--product_name', 'Lock',
+                                   '--product_name', 'Lock Gen2',
+                                   '--product_label', 'Lock',
+                                   '--part_number', 'PCA10056',
                                    '--date', '2022-07-20',
                                    '--hw_ver', '101',
                                    '--hw_ver_str', 'v1.1',
@@ -177,7 +179,9 @@ def test_generate_factory_data_all_specified(self):
             self.assertEqual(factory_data.get('vendor_id'), 0x127F)
             self.assertEqual(factory_data.get('product_id'), 0xABCD)
             self.assertEqual(factory_data.get('vendor_name'), 'Nordic Semiconductor ASA')
-            self.assertEqual(factory_data.get('product_name'), 'Lock')
+            self.assertEqual(factory_data.get('product_name'), 'Lock Gen2')
+            self.assertEqual(factory_data.get('product_label'), 'Lock')
+            self.assertEqual(factory_data.get('part_number'), 'PCA10056')
             self.assertEqual(factory_data.get('date'), '2022-07-20')
             self.assertEqual(factory_data.get('hw_ver'), 101)
             self.assertEqual(factory_data.get('hw_ver_str'), 'v1.1')
diff --git a/src/app/clusters/door-lock-server/door-lock-server-callback.cpp b/src/app/clusters/door-lock-server/door-lock-server-callback.cpp
index 699c0d9c03a759..c9c38f3fb23b5d 100644
--- a/src/app/clusters/door-lock-server/door-lock-server-callback.cpp
+++ b/src/app/clusters/door-lock-server/door-lock-server-callback.cpp
@@ -61,6 +61,8 @@ emberAfPluginDoorLockOnDoorUnlockCommand(chip::EndpointId endpointId, const Opti
     return false;
 }
 
+void __attribute__((weak)) emberAfPluginDoorLockOnAutoRelock(chip::EndpointId endpointId) {}
+
 // =============================================================================
 // 'Default' pre-change callbacks for cluster attributes
 // =============================================================================
diff --git a/src/app/clusters/door-lock-server/door-lock-server.cpp b/src/app/clusters/door-lock-server/door-lock-server.cpp
index 1465f22809cb5d..4b46b80ffe6f5f 100644
--- a/src/app/clusters/door-lock-server/door-lock-server.cpp
+++ b/src/app/clusters/door-lock-server/door-lock-server.cpp
@@ -69,8 +69,6 @@ class DoorLockClusterFabricDelegate : public chip::FabricTable::Delegate
 };
 static DoorLockClusterFabricDelegate gFabricDelegate;
 
-void emberAfPluginDoorLockOnAutoRelock(chip::EndpointId endpointId);
-
 /**********************************************************
  * DoorLockServer public methods
  *********************************************************/
@@ -3380,7 +3378,7 @@ void DoorLockServer::ScheduleAutoRelock(chip::EndpointId endpointId, uint32_t ti
     emberEventControlSetInactive(&AutolockEvent);
 
     AutolockEvent.endpoint = endpointId;
-    AutolockEvent.callback = emberAfPluginDoorLockOnAutoRelock;
+    AutolockEvent.callback = DoorLockOnAutoRelockCallback;
 
     uint32_t timeoutMs =
         (DOOR_LOCK_MAX_LOCK_TIMEOUT_SEC >= timeoutSec) ? timeoutSec * MILLISECOND_TICKS_PER_SECOND : DOOR_LOCK_MAX_LOCK_TIMEOUT_SEC;
@@ -3751,8 +3749,10 @@ void MatterDoorLockClusterServerAttributeChangedCallback(const app::ConcreteAttr
 // Timer callbacks
 // =============================================================================
 
-void emberAfPluginDoorLockOnAutoRelock(chip::EndpointId endpointId)
+void DoorLockServer::DoorLockOnAutoRelockCallback(chip::EndpointId endpointId)
 {
+    emberAfDoorLockClusterPrintln("Door Auto relock timer expired. Locking...");
     emberEventControlSetInactive(&DoorLockServer::Instance().AutolockEvent);
     DoorLockServer::Instance().SetLockState(endpointId, DlLockState::kLocked, DlOperationSource::kAuto);
+    emberAfPluginDoorLockOnAutoRelock(endpointId);
 }
diff --git a/src/app/clusters/door-lock-server/door-lock-server.h b/src/app/clusters/door-lock-server/door-lock-server.h
index c0dc7aef6aa8f9..c7ddf369f8871a 100644
--- a/src/app/clusters/door-lock-server/door-lock-server.h
+++ b/src/app/clusters/door-lock-server/door-lock-server.h
@@ -410,6 +410,8 @@ class DoorLockServer
      */
     void ScheduleAutoRelock(chip::EndpointId endpointId, uint32_t timeoutSec);
 
+    static void DoorLockOnAutoRelockCallback(chip::EndpointId endpointId);
+
     /**
      * @brief Send generic event
      *
@@ -463,8 +465,6 @@ class DoorLockServer
         chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
         const chip::app::Clusters::DoorLock::Commands::UnlockWithTimeout::DecodableType & commandData);
 
-    friend void emberAfPluginDoorLockOnAutoRelock(chip::EndpointId endpointId);
-
     friend bool emberAfDoorLockClusterSetHolidayScheduleCallback(
         chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
         const chip::app::Clusters::DoorLock::Commands::SetHolidaySchedule::DecodableType & commandData);
@@ -887,6 +887,13 @@ bool emberAfPluginDoorLockOnDoorLockCommand(chip::EndpointId endpointId, const O
 bool emberAfPluginDoorLockOnDoorUnlockCommand(chip::EndpointId endpointId, const Optional<chip::ByteSpan> & pinCode,
                                               DlOperationError & err);
 
+/**
+ * @brief This callback is called when the AutoRelock timer is expired.
+ *
+ * @param endpointId ID of the endpoint that contains the door lock to be relocked.
+ */
+void emberAfPluginDoorLockOnAutoRelock(chip::EndpointId endpointId);
+
 /**
  * @brief This callback is called when Door Lock cluster needs to access the users database.
  *
diff --git a/src/controller/SetUpCodePairer.cpp b/src/controller/SetUpCodePairer.cpp
index 64b2459ce5faeb..09ee3a012a4021 100644
--- a/src/controller/SetUpCodePairer.cpp
+++ b/src/controller/SetUpCodePairer.cpp
@@ -223,7 +223,7 @@ bool SetUpCodePairer::ConnectToDiscoveredDevice()
         // Remove it from the queue before we try to connect, in case the
         // connection attempt fails and calls right back into us to try the next
         // thing.
-        RendezvousParameters params(mDiscoveredParameters.front());
+        SetUpCodePairerParameters params(mDiscoveredParameters.front());
         mDiscoveredParameters.pop();
 
         params.SetSetupPINCode(mSetUpPINCode);
@@ -237,6 +237,11 @@ bool SetUpCodePairer::ConnectToDiscoveredDevice()
         // Handle possibly-sync call backs from attempts to establish PASE.
         ExpectPASEEstablishment();
 
+        if (params.GetPeerAddress().GetTransportType() == Transport::Type::kUdp)
+        {
+            mCurrentPASEParameters.SetValue(params);
+        }
+
         CHIP_ERROR err;
         if (mConnectionType == SetupCodePairerBehaviour::kCommission)
         {
@@ -267,9 +272,7 @@ void SetUpCodePairer::OnDiscoveredDeviceOverBle(BLE_CONNECTION_OBJECT connObj)
 
     mWaitingForDiscovery[kBLETransport] = false;
 
-    Transport::PeerAddress peerAddress = Transport::PeerAddress::BLE();
-    mDiscoveredParameters.emplace();
-    mDiscoveredParameters.back().SetPeerAddress(peerAddress).SetConnectionObject(connObj);
+    mDiscoveredParameters.emplace(connObj);
     ConnectToDiscoveredDevice();
 }
 
@@ -338,25 +341,7 @@ void SetUpCodePairer::NotifyCommissionableDeviceDiscovered(const Dnssd::Discover
 
     ChipLogProgress(Controller, "Discovered device to be commissioned over DNS-SD");
 
-    Inet::InterfaceId interfaceId =
-        nodeData.resolutionData.ipAddress[0].IsIPv6LinkLocal() ? nodeData.resolutionData.interfaceId : Inet::InterfaceId::Null();
-    Transport::PeerAddress peerAddress =
-        Transport::PeerAddress::UDP(nodeData.resolutionData.ipAddress[0], nodeData.resolutionData.port, interfaceId);
-    mDiscoveredParameters.emplace();
-    mDiscoveredParameters.back().SetPeerAddress(peerAddress);
-
-    if (nodeData.resolutionData.mrpRetryIntervalIdle.HasValue())
-    {
-        auto interval = nodeData.resolutionData.mrpRetryIntervalIdle.Value();
-        mDiscoveredParameters.back().SetIdleInterval(interval);
-    }
-
-    if (nodeData.resolutionData.mrpRetryIntervalActive.HasValue())
-    {
-        auto interval = nodeData.resolutionData.mrpRetryIntervalActive.Value();
-        mDiscoveredParameters.back().SetActiveInterval(interval);
-    }
-
+    mDiscoveredParameters.emplace(nodeData.resolutionData);
     ConnectToDiscoveredDevice();
 }
 
@@ -412,6 +397,7 @@ void SetUpCodePairer::ResetDiscoveryState()
         mDiscoveredParameters.pop();
     }
 
+    mCurrentPASEParameters.ClearValue();
     mLastPASEError = CHIP_NO_ERROR;
 }
 
@@ -488,6 +474,21 @@ void SetUpCodePairer::OnPairingComplete(CHIP_ERROR error)
         return;
     }
 
+    // It may happen that there is a stale DNS entry. If so, ReconfirmRecord will flush
+    // the record from the daemon cache once it determines that it is invalid.
+    // It may not help for this particular resolve, but may help subsequent resolves.
+    if (CHIP_ERROR_TIMEOUT == error && mCurrentPASEParameters.HasValue())
+    {
+        const auto & params = mCurrentPASEParameters.Value();
+        auto & ip           = params.GetPeerAddress().GetIPAddress();
+        auto err            = Dnssd::Resolver::Instance().ReconfirmRecord(params.mHostName, ip, params.mInterfaceId);
+        if (CHIP_NO_ERROR != err && CHIP_ERROR_NOT_IMPLEMENTED != err)
+        {
+            ChipLogError(Controller, "Error when verifying the validity of an address: %" CHIP_ERROR_FORMAT, err.Format());
+        }
+    }
+    mCurrentPASEParameters.ClearValue();
+
     // We failed to establish PASE.  Try the next thing we have discovered, if
     // any.
     if (TryNextRendezvousParameters())
@@ -541,5 +542,32 @@ void SetUpCodePairer::OnDeviceDiscoveredTimeoutCallback(System::Layer * layer, v
     }
 }
 
+SetUpCodePairerParameters::SetUpCodePairerParameters(const Dnssd::CommonResolutionData & data)
+{
+    mInterfaceId = data.interfaceId;
+    Platform::CopyString(mHostName, data.hostName);
+
+    auto & ip = data.ipAddress[0];
+    SetPeerAddress(Transport::PeerAddress::UDP(ip, data.port, ip.IsIPv6LinkLocal() ? data.interfaceId : Inet::InterfaceId::Null()));
+
+    if (data.mrpRetryIntervalIdle.HasValue())
+    {
+        SetIdleInterval(data.mrpRetryIntervalIdle.Value());
+    }
+
+    if (data.mrpRetryIntervalActive.HasValue())
+    {
+        SetActiveInterval(data.mrpRetryIntervalActive.Value());
+    }
+}
+
+#if CONFIG_NETWORK_LAYER_BLE
+SetUpCodePairerParameters::SetUpCodePairerParameters(BLE_CONNECTION_OBJECT connObj)
+{
+    Transport::PeerAddress peerAddress = Transport::PeerAddress::BLE();
+    SetPeerAddress(peerAddress).SetConnectionObject(connObj);
+}
+#endif // CONFIG_NETWORK_LAYER_BLE
+
 } // namespace Controller
 } // namespace chip
diff --git a/src/controller/SetUpCodePairer.h b/src/controller/SetUpCodePairer.h
index ed1c6f0c2ad5ac..eae15065d75966 100644
--- a/src/controller/SetUpCodePairer.h
+++ b/src/controller/SetUpCodePairer.h
@@ -48,6 +48,17 @@ namespace Controller {
 
 class DeviceCommissioner;
 
+class SetUpCodePairerParameters : public RendezvousParameters
+{
+public:
+    SetUpCodePairerParameters(const Dnssd::CommonResolutionData & data);
+#if CONFIG_NETWORK_LAYER_BLE
+    SetUpCodePairerParameters(BLE_CONNECTION_OBJECT connObj);
+#endif // CONFIG_NETWORK_LAYER_BLE
+    char mHostName[Dnssd::kHostNameMaxLength + 1] = {};
+    Inet::InterfaceId mInterfaceId;
+};
+
 enum class SetupCodePairerBehaviour : uint8_t
 {
     kCommission,
@@ -180,7 +191,12 @@ class DLL_EXPORT SetUpCodePairer : public DevicePairingDelegate
     // Queue of things we have discovered but not tried connecting to yet.  The
     // general discovery/pairing process will terminate once this queue is empty
     // and all the booleans in mWaitingForDiscovery are false.
-    std::queue<RendezvousParameters> mDiscoveredParameters;
+    std::queue<SetUpCodePairerParameters> mDiscoveredParameters;
+
+    // Current thing we are trying to connect to over UDP. If a PASE connection fails with
+    // a CHIP_ERROR_TIMEOUT, the discovered parameters will be used to ask the
+    // mdns daemon to invalidate the
+    Optional<SetUpCodePairerParameters> mCurrentPASEParameters;
 
     // mWaitingForPASE is true if we have called either
     // EstablishPASEConnection or PairDevice on mCommissioner and are now just
diff --git a/src/controller/java/src/chip/devicecontroller/NetworkCredentials.java b/src/controller/java/src/chip/devicecontroller/NetworkCredentials.java
index e2ec432bf06acb..adb98170677ce5 100644
--- a/src/controller/java/src/chip/devicecontroller/NetworkCredentials.java
+++ b/src/controller/java/src/chip/devicecontroller/NetworkCredentials.java
@@ -17,15 +17,15 @@
  */
 package chip.devicecontroller;
 
-import android.os.Parcel;
-import android.os.Parcelable;
 import javax.annotation.Nullable;
 
 /** Class for holding WiFi or Thread credentials, but not both. */
-public class NetworkCredentials implements Parcelable {
+public class NetworkCredentials {
   @Nullable private WiFiCredentials wifiCredentials;
   @Nullable private ThreadCredentials threadCredentials;
 
+  public NetworkCredentials() {}
+
   private NetworkCredentials(
       @Nullable WiFiCredentials wifiCredentials, @Nullable ThreadCredentials threadCredentials) {
     this.wifiCredentials = wifiCredentials;
@@ -54,38 +54,23 @@ public ThreadCredentials getThreadCredentials() {
     return threadCredentials;
   }
 
-  // Begin Parcelable implementation
-
-  private NetworkCredentials(Parcel in) {
-    wifiCredentials = in.readParcelable(WiFiCredentials.class.getClassLoader());
-    threadCredentials = in.readParcelable(ThreadCredentials.class.getClassLoader());
-  }
-
-  public int describeContents() {
-    return 0;
+  public void setWiFiCredentials(String ssid, String password) {
+    wifiCredentials.set(ssid, password);
   }
 
-  public void writeToParcel(Parcel out, int flags) {
-    out.writeParcelable(wifiCredentials, 0);
-    out.writeParcelable(threadCredentials, 0);
+  public void setThreadCredentials(byte[] operationalDataset) {
+    threadCredentials.set(operationalDataset);
   }
 
-  public static final Parcelable.Creator<NetworkCredentials> CREATOR =
-      new Parcelable.Creator<NetworkCredentials>() {
-        public NetworkCredentials createFromParcel(Parcel in) {
-          return new NetworkCredentials(in);
-        }
-
-        public NetworkCredentials[] newArray(int size) {
-          return new NetworkCredentials[size];
-        }
-      };
-
-  public static class WiFiCredentials implements Parcelable {
-    private final String ssid;
-    private final String password;
+  public static class WiFiCredentials {
+    private String ssid;
+    private String password;
 
     public WiFiCredentials(String ssid, String password) {
+      set(ssid, password);
+    }
+
+    public void set(String ssid, String password) {
       this.ssid = ssid;
       this.password = password;
     }
@@ -97,71 +82,21 @@ public String getSsid() {
     public String getPassword() {
       return password;
     }
-
-    // Begin Parcelable implementation
-
-    private WiFiCredentials(Parcel in) {
-      ssid = in.readString();
-      password = in.readString();
-    }
-
-    public int describeContents() {
-      return 0;
-    }
-
-    public void writeToParcel(Parcel out, int flags) {
-      out.writeString(ssid);
-      out.writeString(password);
-    }
-
-    public static final Parcelable.Creator<WiFiCredentials> CREATOR =
-        new Parcelable.Creator<WiFiCredentials>() {
-          public WiFiCredentials createFromParcel(Parcel in) {
-            return new WiFiCredentials(in);
-          }
-
-          public WiFiCredentials[] newArray(int size) {
-            return new WiFiCredentials[size];
-          }
-        };
   }
 
-  public static class ThreadCredentials implements Parcelable {
-    private final byte[] operationalDataset;
+  public static class ThreadCredentials {
+    private byte[] operationalDataset;
 
     public ThreadCredentials(byte[] operationalDataset) {
+      set(operationalDataset);
+    }
+
+    public void set(byte[] operationalDataset) {
       this.operationalDataset = operationalDataset;
     }
 
     public byte[] getOperationalDataset() {
       return operationalDataset;
     }
-
-    // Begin Parcelable implementation
-
-    private ThreadCredentials(Parcel in) {
-      operationalDataset = new byte[in.readInt()];
-      in.readByteArray(operationalDataset);
-    }
-
-    public int describeContents() {
-      return 0;
-    }
-
-    public void writeToParcel(Parcel out, int flags) {
-      out.writeInt(operationalDataset.length);
-      out.writeByteArray(operationalDataset);
-    }
-
-    public static final Parcelable.Creator<ThreadCredentials> CREATOR =
-        new Parcelable.Creator<ThreadCredentials>() {
-          public ThreadCredentials createFromParcel(Parcel in) {
-            return new ThreadCredentials(in);
-          }
-
-          public ThreadCredentials[] newArray(int size) {
-            return new ThreadCredentials[size];
-          }
-        };
   }
 }
diff --git a/src/controller/tests/TestCommissionableNodeController.cpp b/src/controller/tests/TestCommissionableNodeController.cpp
index 41d5663bafb0b6..dc841b4482e4c0 100644
--- a/src/controller/tests/TestCommissionableNodeController.cpp
+++ b/src/controller/tests/TestCommissionableNodeController.cpp
@@ -43,6 +43,10 @@ class MockResolver : public Resolver
         return CHIP_ERROR_NOT_IMPLEMENTED;
     }
     CHIP_ERROR StopDiscovery() override { return CHIP_ERROR_NOT_IMPLEMENTED; }
+    CHIP_ERROR ReconfirmRecord(const char * hostname, Inet::IPAddress address, Inet::InterfaceId interfaceId) override
+    {
+        return CHIP_ERROR_NOT_IMPLEMENTED;
+    }
 
     CHIP_ERROR InitStatus                  = CHIP_NO_ERROR;
     CHIP_ERROR ResolveNodeIdStatus         = CHIP_NO_ERROR;
diff --git a/src/darwin/Framework/CHIP/MTRControllerFactory.mm b/src/darwin/Framework/CHIP/MTRControllerFactory.mm
index 3d77b893229d7b..88f0cc70401856 100644
--- a/src/darwin/Framework/CHIP/MTRControllerFactory.mm
+++ b/src/darwin/Framework/CHIP/MTRControllerFactory.mm
@@ -39,6 +39,7 @@
 #include <credentials/attestation_verifier/DefaultDeviceAttestationVerifier.h>
 #include <credentials/attestation_verifier/DeviceAttestationVerifier.h>
 #include <crypto/PersistentStorageOperationalKeystore.h>
+#include <lib/support/Pool.h>
 #include <lib/support/TestPersistentStorageDelegate.h>
 #include <platform/PlatformManager.h>
 
@@ -309,6 +310,11 @@ - (BOOL)startup:(MTRControllerFactoryParams *)startupParams
             return;
         }
 
+        // This needs to happen after DeviceControllerFactory::Init,
+        // because that creates (lazily, by calling functions with
+        // static variables in them) some static-lifetime objects.
+        chip::HeapObjectPoolExitHandling::IgnoreLeaksOnExit();
+
         // Make sure we don't leave a system state running while we have no
         // controllers started.  This is working around the fact that a system
         // state is brought up live on factory init, and not when it comes time
diff --git a/src/darwin/Framework/CHIP/MTRDevice.h b/src/darwin/Framework/CHIP/MTRDevice.h
index 90f5869138023c..eb13cbe962643d 100644
--- a/src/darwin/Framework/CHIP/MTRDevice.h
+++ b/src/darwin/Framework/CHIP/MTRDevice.h
@@ -87,7 +87,7 @@ typedef NS_ENUM(NSUInteger, MTRDeviceState) {
  *                    MTRDeviceResponseHandler.
  *
  * @param expectedValueInterval  maximum interval in milliseconds during which reads of the attribute will return the value being
- * written. This value will be clamped to timeoutMs
+ * written. This value must be within [1, UINT32_MAX], and will be clamped to this range.
  *
  * TODO: document that -readAttribute... will return the expected value for the [endpoint,cluster,attribute] until one of the
  * following:
@@ -96,7 +96,8 @@ typedef NS_ENUM(NSUInteger, MTRDeviceState) {
  *  3. We succeed at writing the attribute.
  *  4. We fail at writing the attribute and give up on the write
  *
- * @param timeout   timeout in milliseconds for timed write, or nil.
+ * @param timeout   timeout in milliseconds for timed write, or nil. This value must be within [1, UINT16_MAX], and will be clamped
+ * to this range.
  * TODO: make timeout arguments uniform
  */
 - (void)writeAttributeWithEndpointID:(NSNumber *)endpointID
@@ -117,13 +118,18 @@ typedef NS_ENUM(NSUInteger, MTRDeviceState) {
  * @param expectedValues  array of dictionaries containing the expected values in the same format as
  *                       attribute read completion handler. Requires MTRAttributePathKey values.
  *                       See MTRDeviceResponseHandler definition for dictionary details.
+ *                       The expectedValues and expectedValueInterval arguments need to be both
+ *                       nil or both non-nil, or both will be both ignored.
+ *
  * TODO: document better the expectedValues is how this command is expected to change attributes when read, and that the next
  * readAttribute will get these values
  *
  * @param expectedValueInterval  maximum interval in milliseconds during which reads of the attribute will return the value being
- * written. This value will be clamped to timeout
+ * written. If the value is less than 1, both this value and expectedValues will be ignored.
+            If this value is greater than UINT32_MAX, it will be clamped to UINT32_MAX.
  *
- * @param timeout   timeout in milliseconds for timed invoke, or nil.
+ * @param timeout   timeout in milliseconds for timed invoke, or nil. This value must be within [1, UINT16_MAX], and will be clamped
+ * to this range.
  *
  * @param completion  response handler will receive either values or error.
  */
diff --git a/src/darwin/Framework/CHIP/MTRDevice.mm b/src/darwin/Framework/CHIP/MTRDevice.mm
index 486b5bac17fb69..7bce5899c686f3 100644
--- a/src/darwin/Framework/CHIP/MTRDevice.mm
+++ b/src/darwin/Framework/CHIP/MTRDevice.mm
@@ -92,6 +92,16 @@ - (id)strongObject
 }
 @end
 
+NSNumber * MTRClampedNumber(NSNumber * aNumber, NSNumber * min, NSNumber * max)
+{
+    if ([aNumber compare:min] == NSOrderedAscending) {
+        return min;
+    } else if ([aNumber compare:max] == NSOrderedDescending) {
+        return max;
+    }
+    return aNumber;
+}
+
 #pragma mark - SubscriptionCallback class declaration
 using namespace chip;
 using namespace chip::app;
@@ -136,8 +146,6 @@ @interface MTRDevice ()
 @property (nonatomic) NSMutableDictionary<MTRAttributePath *, MTRPair<NSDate *, NSDictionary *> *> * expectedValueCache;
 
 @property (nonatomic) BOOL expirationCheckScheduled;
-
-@property (nonatomic) MTRAsyncCallbackWorkQueue * asyncCallbackWorkQueue;
 @end
 
 @implementation MTRDevice
@@ -382,7 +390,7 @@ - (void)subscribeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)max
     // Create work item, set ready handler to perform task, then enqueue the work
     MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:_queue];
     MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
-        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.nodeID controller:self.deviceController];
+        MTRBaseDevice * baseDevice = [self newBaseDevice];
 
         [baseDevice
             readAttributeWithEndpointId:endpointID
@@ -398,7 +406,7 @@ - (void)subscribeWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)max
                                  }
 
                                  // TODO: better retry logic
-                                 if (retryCount < 2) {
+                                 if (error && (retryCount < 2)) {
                                      [workItem retryWork];
                                  } else {
                                      [workItem endWork];
@@ -424,20 +432,29 @@ - (void)writeAttributeWithEndpointID:(NSNumber *)endpointID
                expectedValueInterval:(NSNumber *)expectedValueInterval
                    timedWriteTimeout:(NSNumber * _Nullable)timeout
 {
-    // Start the asynchronous operation
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.nodeID controller:self.deviceController];
-    [baseDevice
-        writeAttributeWithEndpointId:endpointID
-                           clusterId:clusterID
-                         attributeId:attributeID
-                               value:value
-                   timedWriteTimeout:timeout
-                         clientQueue:self.queue
-                          completion:^(NSArray<NSDictionary<NSString *, id> *> * _Nullable values, NSError * _Nullable error) {
-                              if (values) {
-                                  [self _handleAttributeReport:values];
-                              }
-                          }];
+    if (timeout) {
+        timeout = MTRClampedNumber(timeout, @(1), @(UINT16_MAX));
+    }
+    expectedValueInterval = MTRClampedNumber(expectedValueInterval, @(1), @(UINT32_MAX));
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:_queue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [self newBaseDevice];
+        [baseDevice
+            writeAttributeWithEndpointId:endpointID
+                               clusterId:clusterID
+                             attributeId:attributeID
+                                   value:value
+                       timedWriteTimeout:timeout
+                             clientQueue:self.queue
+                              completion:^(NSArray<NSDictionary<NSString *, id> *> * _Nullable values, NSError * _Nullable error) {
+                                  if (values) {
+                                      [self _handleAttributeReport:values];
+                                  }
+                                  [workItem endWork];
+                              }];
+    };
+    workItem.readyHandler = readyHandler;
+    [_asyncCallbackWorkQueue enqueueWorkItem:workItem];
 
     // Commit change into expected value cache
     MTRAttributePath * attributePath = [MTRAttributePath attributePathWithEndpointId:endpointID
@@ -452,28 +469,43 @@ - (void)invokeCommandWithEndpointID:(NSNumber *)endpointID
                           clusterID:(NSNumber *)clusterID
                           commandID:(NSNumber *)commandID
                       commandFields:(id)commandFields
-                     expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
-              expectedValueInterval:(NSNumber *)expectedValueInterval
+                     expectedValues:(NSArray<NSDictionary<NSString *, id> *> * _Nullable)expectedValues
+              expectedValueInterval:(NSNumber * _Nullable)expectedValueInterval
                  timedInvokeTimeout:(NSNumber * _Nullable)timeout
                         clientQueue:(dispatch_queue_t)clientQueue
                          completion:(MTRDeviceResponseHandler)completion
 {
-    // Perform this operation
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.nodeID controller:self.deviceController];
-    [baseDevice
-        invokeCommandWithEndpointId:endpointID
-                          clusterId:clusterID
-                          commandId:commandID
-                      commandFields:commandFields
-                 timedInvokeTimeout:timeout
-                        clientQueue:self.queue
-                         completion:^(NSArray<NSDictionary<NSString *, id> *> * _Nullable values, NSError * _Nullable error) {
-                             dispatch_async(clientQueue, ^{
-                                 completion(values, error);
-                             });
-                         }];
-
-    [self setExpectedValues:expectedValues expectedValueInterval:expectedValueInterval];
+    if (timeout) {
+        timeout = MTRClampedNumber(timeout, @(1), @(UINT16_MAX));
+    }
+    if (!expectedValueInterval || ([expectedValueInterval compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueInterval = MTRClampedNumber(expectedValueInterval, @(1), @(UINT32_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:_queue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [self newBaseDevice];
+        [baseDevice
+            invokeCommandWithEndpointId:endpointID
+                              clusterId:clusterID
+                              commandId:commandID
+                          commandFields:commandFields
+                     timedInvokeTimeout:timeout
+                            clientQueue:self.queue
+                             completion:^(NSArray<NSDictionary<NSString *, id> *> * _Nullable values, NSError * _Nullable error) {
+                                 dispatch_async(clientQueue, ^{
+                                     completion(values, error);
+                                 });
+                                 [workItem endWork];
+                             }];
+    };
+    workItem.readyHandler = readyHandler;
+    [_asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (expectedValues) {
+        [self setExpectedValues:expectedValues expectedValueInterval:expectedValueInterval];
+    }
 }
 
 - (void)openCommissioningWindowWithSetupPasscode:(NSNumber *)setupPasscode
@@ -482,7 +514,7 @@ - (void)openCommissioningWindowWithSetupPasscode:(NSNumber *)setupPasscode
                                            queue:(dispatch_queue_t)queue
                                       completion:(MTRDeviceOpenCommissioningWindowHandler)completion
 {
-    auto * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.nodeID controller:self.deviceController];
+    auto * baseDevice = [self newBaseDevice];
     [baseDevice openCommissioningWindowWithSetupPasscode:setupPasscode
                                            discriminator:discriminator
                                                 duration:duration
@@ -702,6 +734,11 @@ - (void)setExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)values expe
     os_unfair_lock_unlock(&self->_lock);
 }
 
+- (MTRBaseDevice *)newBaseDevice
+{
+    return [[MTRBaseDevice alloc] initWithNodeID:self.nodeID controller:self.deviceController];
+}
+
 @end
 
 #pragma mark - SubscriptionCallback
diff --git a/src/darwin/Framework/CHIP/MTRDevice_Internal.h b/src/darwin/Framework/CHIP/MTRDevice_Internal.h
index 8be51b0e3fa46c..a130a3ea6c8a8f 100644
--- a/src/darwin/Framework/CHIP/MTRDevice_Internal.h
+++ b/src/darwin/Framework/CHIP/MTRDevice_Internal.h
@@ -35,7 +35,13 @@ typedef void (^MTRDevicePerformAsyncBlock)(MTRBaseDevice * baseDevice);
 
 @property (nonatomic, readonly, strong, nonnull) MTRDeviceController * deviceController;
 @property (nonatomic, readonly) uint64_t nodeID;
+@property (nonatomic, readonly) MTRAsyncCallbackWorkQueue * asyncCallbackWorkQueue;
 
 @end
 
+#pragma mark - Utility for clamping numbers
+// Returns a NSNumber object that is aNumber if it falls within the range [min, max].
+// Returns min or max, if it is below or above, respectively.
+NSNumber * MTRClampedNumber(NSNumber * aNumber, NSNumber * min, NSNumber * max);
+
 NS_ASSUME_NONNULL_END
diff --git a/src/darwin/Framework/CHIP/templates/MTRClusters-src.zapt b/src/darwin/Framework/CHIP/templates/MTRClusters-src.zapt
index d2da8c753c656a..d4e3087a56f80e 100644
--- a/src/darwin/Framework/CHIP/templates/MTRClusters-src.zapt
+++ b/src/darwin/Framework/CHIP/templates/MTRClusters-src.zapt
@@ -3,6 +3,7 @@
 #import <Foundation/Foundation.h>
 
 #import "MTRAttributeCacheContainer_Internal.h"
+#import "MTRAsyncCallbackWorkQueue.h"
 #import "MTRBaseDevice_internal.h"
 #import "MTRClusterConstants.h"
 #import "MTRClusters_internal.h"
@@ -52,56 +53,71 @@ using chip::SessionHandle;
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice *baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTR{{>callbackName}}CallbackBridge(self.callbackQueue,
-      baseDevice,
-      {{#if hasSpecificResponse}}
-        {{! This treats completionHandler as taking an id for the data.  This is
-            not great from a type-safety perspective, of course. }}
-        completionHandler,
-      {{else}}
-        {{! For now, don't change the bridge API; instead just use an adapter
-            to invoke our completion handler. This is not great from a
-            type-safety perspective, of course. }}
-        ^(id _Nullable value, NSError * _Nullable error) {
-          completionHandler(error);
-        },
-      {{/if}}
-      ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-        chip::Optional<uint16_t> timedInvokeTimeoutMs;
-        ListFreer listFreer;
-        {{asUpperCamelCase parent.name}}::Commands::{{asUpperCamelCase name}}::Type request;
-        if (params != nil) {
-          if (params.timedInvokeTimeoutMs != nil) {
-            timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-          }
-        }
-        {{#if mustUseTimedInvoke}}
-        if (!timedInvokeTimeoutMs.HasValue()) {
-          timedInvokeTimeoutMs.SetValue(10000);
-        }
-        {{/if}}
-        {{#chip_cluster_command_arguments}}
-          {{#first}}
-            {{#unless (commandHasRequiredField parent)}}
-            if (params != nil) {
-            {{/unless}}
-          {{/first}}
-          {{>encode_value target=(concat "request." (asLowerCamelCase label)) source=(concat "params." (asStructPropertyName label)) cluster=parent.parent.name errorCode="return CHIP_ERROR_INVALID_ARGUMENT;" depth=0}}
-          {{#last}}
-            {{#unless (commandHasRequiredField parent)}}
+    NSNumber *timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+      timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice *baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
+        new MTR{{>callbackName}}CallbackBridge(self.callbackQueue,
+          baseDevice,
+          {{#if hasSpecificResponse}}
+            {{! This treats completionHandler as taking an id for the data.  This is
+                not great from a type-safety perspective, of course. }}
+            completionHandler,
+          {{else}}
+            {{! For now, don't change the bridge API; instead just use an adapter
+                to invoke our completion handler. This is not great from a
+                type-safety perspective, of course. }}
+            ^(id _Nullable value, NSError * _Nullable error) {
+              completionHandler(error);
+                  [workItem endWork];
+            },
+          {{/if}}
+          ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+            chip::Optional<uint16_t> timedInvokeTimeoutMs;
+            ListFreer listFreer;
+            {{asUpperCamelCase parent.name}}::Commands::{{asUpperCamelCase name}}::Type request;
+            if (timedInvokeTimeoutMsParam != nil) {
+              timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
             }
-           {{/unless}}
-          {{/last}}
-        {{/chip_cluster_command_arguments}}
-
-        auto successFn = Callback<{{>callbackName}}CallbackType>::FromCancelable(success);
-        auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-        chip::Controller::{{asUpperCamelCase parent.name}}Cluster cppCluster(exchangeManager, session, self->_endpoint);
-        return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-    });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+            {{#if mustUseTimedInvoke}}
+            if (!timedInvokeTimeoutMs.HasValue()) {
+              timedInvokeTimeoutMs.SetValue(10000);
+            }
+            {{/if}}
+            {{#chip_cluster_command_arguments}}
+              {{#first}}
+                {{#unless (commandHasRequiredField parent)}}
+                if (params != nil) {
+                {{/unless}}
+              {{/first}}
+              {{>encode_value target=(concat "request." (asLowerCamelCase label)) source=(concat "params." (asStructPropertyName label)) cluster=parent.parent.name errorCode="return CHIP_ERROR_INVALID_ARGUMENT;" depth=0}}
+              {{#last}}
+                {{#unless (commandHasRequiredField parent)}}
+                }
+               {{/unless}}
+              {{/last}}
+            {{/chip_cluster_command_arguments}}
+
+            auto successFn = Callback<{{>callbackName}}CallbackType>::FromCancelable(success);
+            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+            chip::Controller::{{asUpperCamelCase parent.name}}Cluster cppCluster(exchangeManager, session, self->_endpoint);
+            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+      });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+      expectedValues = nil;
+    } else {
+      expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+      [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 {{/chip_cluster_commands}}
 
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm
index 5aa5ac5ed74270..f83075735e9931 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm
@@ -19,6 +19,7 @@
 
 #import <Foundation/Foundation.h>
 
+#import "MTRAsyncCallbackWorkQueue.h"
 #import "MTRAttributeCacheContainer_Internal.h"
 #import "MTRBaseDevice_internal.h"
 #import "MTRCallbackBridge_internal.h"
@@ -63,30 +64,47 @@ - (void)identifyWithParams:(MTRIdentifyClusterIdentifyParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Identify::Commands::Identify::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.identifyTime = params.identifyTime.unsignedShortValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Identify::Commands::Identify::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.identifyTime = params.identifyTime.unsignedShortValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)triggerEffectWithParams:(MTRIdentifyClusterTriggerEffectParams *)params
@@ -96,33 +114,50 @@ - (void)triggerEffectWithParams:(MTRIdentifyClusterTriggerEffectParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Identify::Commands::TriggerEffect::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.effectIdentifier = static_cast<std::remove_reference_t<decltype(request.effectIdentifier)>>(
-                params.effectIdentifier.unsignedCharValue);
-            request.effectVariant
-                = static_cast<std::remove_reference_t<decltype(request.effectVariant)>>(params.effectVariant.unsignedCharValue);
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Identify::Commands::TriggerEffect::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.effectIdentifier = static_cast<std::remove_reference_t<decltype(request.effectIdentifier)>>(
+                    params.effectIdentifier.unsignedCharValue);
+                request.effectVariant
+                    = static_cast<std::remove_reference_t<decltype(request.effectVariant)>>(params.effectVariant.unsignedCharValue);
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeIdentifyTimeWithParams:(MTRReadParams * _Nullable)params
@@ -225,27 +260,43 @@ - (void)addGroupWithParams:(MTRGroupsClusterAddGroupParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRGroupsClusterAddGroupResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Groups::Commands::AddGroup::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRGroupsClusterAddGroupResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Groups::Commands::AddGroup::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.groupId = params.groupId.unsignedShortValue;
-            request.groupName = [self asCharSpan:params.groupName];
-
-            auto successFn = Callback<GroupsClusterAddGroupResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.groupId = params.groupId.unsignedShortValue;
+                request.groupName = [self asCharSpan:params.groupName];
+
+                auto successFn = Callback<GroupsClusterAddGroupResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)viewGroupWithParams:(MTRGroupsClusterViewGroupParams *)params
@@ -256,26 +307,42 @@ - (void)viewGroupWithParams:(MTRGroupsClusterViewGroupParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRGroupsClusterViewGroupResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Groups::Commands::ViewGroup::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRGroupsClusterViewGroupResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Groups::Commands::ViewGroup::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.groupId = params.groupId.unsignedShortValue;
-
-            auto successFn = Callback<GroupsClusterViewGroupResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.groupId = params.groupId.unsignedShortValue;
+
+                auto successFn = Callback<GroupsClusterViewGroupResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)getGroupMembershipWithParams:(MTRGroupsClusterGetGroupMembershipParams *)params
@@ -286,47 +353,63 @@ - (void)getGroupMembershipWithParams:(MTRGroupsClusterGetGroupMembershipParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRGroupsClusterGetGroupMembershipResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Groups::Commands::GetGroupMembership::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            {
-                using ListType_0 = std::remove_reference_t<decltype(request.groupList)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (params.groupList.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.groupList.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < params.groupList.count; ++i_0) {
-                        if (![params.groupList[i_0] isKindOfClass:[NSNumber class]]) {
-                            // Wrong kind of value.
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRGroupsClusterGetGroupMembershipResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Groups::Commands::GetGroupMembership::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                {
+                    using ListType_0 = std::remove_reference_t<decltype(request.groupList)>;
+                    using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+                    if (params.groupList.count != 0) {
+                        auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.groupList.count);
+                        if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                             return CHIP_ERROR_INVALID_ARGUMENT;
                         }
-                        auto element_0 = (NSNumber *) params.groupList[i_0];
-                        listHolder_0->mList[i_0] = element_0.unsignedShortValue;
+                        listFreer.add(listHolder_0);
+                        for (size_t i_0 = 0; i_0 < params.groupList.count; ++i_0) {
+                            if (![params.groupList[i_0] isKindOfClass:[NSNumber class]]) {
+                                // Wrong kind of value.
+                                return CHIP_ERROR_INVALID_ARGUMENT;
+                            }
+                            auto element_0 = (NSNumber *) params.groupList[i_0];
+                            listHolder_0->mList[i_0] = element_0.unsignedShortValue;
+                        }
+                        request.groupList = ListType_0(listHolder_0->mList, params.groupList.count);
+                    } else {
+                        request.groupList = ListType_0();
                     }
-                    request.groupList = ListType_0(listHolder_0->mList, params.groupList.count);
-                } else {
-                    request.groupList = ListType_0();
                 }
-            }
 
-            auto successFn = Callback<GroupsClusterGetGroupMembershipResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<GroupsClusterGetGroupMembershipResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)removeGroupWithParams:(MTRGroupsClusterRemoveGroupParams *)params
@@ -337,26 +420,42 @@ - (void)removeGroupWithParams:(MTRGroupsClusterRemoveGroupParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRGroupsClusterRemoveGroupResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Groups::Commands::RemoveGroup::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRGroupsClusterRemoveGroupResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Groups::Commands::RemoveGroup::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.groupId = params.groupId.unsignedShortValue;
-
-            auto successFn = Callback<GroupsClusterRemoveGroupResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.groupId = params.groupId.unsignedShortValue;
+
+                auto successFn = Callback<GroupsClusterRemoveGroupResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)removeAllGroupsWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -375,29 +474,46 @@ - (void)removeAllGroupsWithParams:(MTRGroupsClusterRemoveAllGroupsParams * _Null
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Groups::Commands::RemoveAllGroups::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Groups::Commands::RemoveAllGroups::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)addGroupIfIdentifyingWithParams:(MTRGroupsClusterAddGroupIfIdentifyingParams *)params
@@ -407,31 +523,48 @@ - (void)addGroupIfIdentifyingWithParams:(MTRGroupsClusterAddGroupIfIdentifyingPa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Groups::Commands::AddGroupIfIdentifying::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.groupId = params.groupId.unsignedShortValue;
-            request.groupName = [self asCharSpan:params.groupName];
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Groups::Commands::AddGroupIfIdentifying::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.groupId = params.groupId.unsignedShortValue;
+                request.groupName = [self asCharSpan:params.groupName];
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeNameSupportWithParams:(MTRReadParams * _Nullable)params
@@ -507,102 +640,119 @@ - (void)addSceneWithParams:(MTRScenesClusterAddSceneParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRScenesClusterAddSceneResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Scenes::Commands::AddScene::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.groupId = params.groupId.unsignedShortValue;
-            request.sceneId = params.sceneId.unsignedCharValue;
-            request.transitionTime = params.transitionTime.unsignedShortValue;
-            request.sceneName = [self asCharSpan:params.sceneName];
-            {
-                using ListType_0 = std::remove_reference_t<decltype(request.extensionFieldSets)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (params.extensionFieldSets.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.extensionFieldSets.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < params.extensionFieldSets.count; ++i_0) {
-                        if (![params.extensionFieldSets[i_0] isKindOfClass:[MTRScenesClusterExtensionFieldSet class]]) {
-                            // Wrong kind of value.
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRScenesClusterAddSceneResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Scenes::Commands::AddScene::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.groupId = params.groupId.unsignedShortValue;
+                request.sceneId = params.sceneId.unsignedCharValue;
+                request.transitionTime = params.transitionTime.unsignedShortValue;
+                request.sceneName = [self asCharSpan:params.sceneName];
+                {
+                    using ListType_0 = std::remove_reference_t<decltype(request.extensionFieldSets)>;
+                    using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+                    if (params.extensionFieldSets.count != 0) {
+                        auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.extensionFieldSets.count);
+                        if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                             return CHIP_ERROR_INVALID_ARGUMENT;
                         }
-                        auto element_0 = (MTRScenesClusterExtensionFieldSet *) params.extensionFieldSets[i_0];
-                        listHolder_0->mList[i_0].clusterId = element_0.clusterId.unsignedIntValue;
-                        {
-                            using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].attributeValueList)>;
-                            using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
-                            if (element_0.attributeValueList.count != 0) {
-                                auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.attributeValueList.count);
-                                if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
-                                    return CHIP_ERROR_INVALID_ARGUMENT;
-                                }
-                                listFreer.add(listHolder_2);
-                                for (size_t i_2 = 0; i_2 < element_0.attributeValueList.count; ++i_2) {
-                                    if (![element_0.attributeValueList[i_2]
-                                            isKindOfClass:[MTRScenesClusterAttributeValuePair class]]) {
-                                        // Wrong kind of value.
+                        listFreer.add(listHolder_0);
+                        for (size_t i_0 = 0; i_0 < params.extensionFieldSets.count; ++i_0) {
+                            if (![params.extensionFieldSets[i_0] isKindOfClass:[MTRScenesClusterExtensionFieldSet class]]) {
+                                // Wrong kind of value.
+                                return CHIP_ERROR_INVALID_ARGUMENT;
+                            }
+                            auto element_0 = (MTRScenesClusterExtensionFieldSet *) params.extensionFieldSets[i_0];
+                            listHolder_0->mList[i_0].clusterId = element_0.clusterId.unsignedIntValue;
+                            {
+                                using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].attributeValueList)>;
+                                using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
+                                if (element_0.attributeValueList.count != 0) {
+                                    auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.attributeValueList.count);
+                                    if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
                                         return CHIP_ERROR_INVALID_ARGUMENT;
                                     }
-                                    auto element_2 = (MTRScenesClusterAttributeValuePair *) element_0.attributeValueList[i_2];
-                                    if (element_2.attributeId != nil) {
-                                        auto & definedValue_4 = listHolder_2->mList[i_2].attributeId.Emplace();
-                                        definedValue_4 = element_2.attributeId.unsignedIntValue;
-                                    }
-                                    {
-                                        using ListType_4
-                                            = std::remove_reference_t<decltype(listHolder_2->mList[i_2].attributeValue)>;
-                                        using ListMemberType_4 = ListMemberTypeGetter<ListType_4>::Type;
-                                        if (element_2.attributeValue.count != 0) {
-                                            auto * listHolder_4 = new ListHolder<ListMemberType_4>(element_2.attributeValue.count);
-                                            if (listHolder_4 == nullptr || listHolder_4->mList == nullptr) {
-                                                return CHIP_ERROR_INVALID_ARGUMENT;
-                                            }
-                                            listFreer.add(listHolder_4);
-                                            for (size_t i_4 = 0; i_4 < element_2.attributeValue.count; ++i_4) {
-                                                if (![element_2.attributeValue[i_4] isKindOfClass:[NSNumber class]]) {
-                                                    // Wrong kind of value.
+                                    listFreer.add(listHolder_2);
+                                    for (size_t i_2 = 0; i_2 < element_0.attributeValueList.count; ++i_2) {
+                                        if (![element_0.attributeValueList[i_2]
+                                                isKindOfClass:[MTRScenesClusterAttributeValuePair class]]) {
+                                            // Wrong kind of value.
+                                            return CHIP_ERROR_INVALID_ARGUMENT;
+                                        }
+                                        auto element_2 = (MTRScenesClusterAttributeValuePair *) element_0.attributeValueList[i_2];
+                                        if (element_2.attributeId != nil) {
+                                            auto & definedValue_4 = listHolder_2->mList[i_2].attributeId.Emplace();
+                                            definedValue_4 = element_2.attributeId.unsignedIntValue;
+                                        }
+                                        {
+                                            using ListType_4
+                                                = std::remove_reference_t<decltype(listHolder_2->mList[i_2].attributeValue)>;
+                                            using ListMemberType_4 = ListMemberTypeGetter<ListType_4>::Type;
+                                            if (element_2.attributeValue.count != 0) {
+                                                auto * listHolder_4
+                                                    = new ListHolder<ListMemberType_4>(element_2.attributeValue.count);
+                                                if (listHolder_4 == nullptr || listHolder_4->mList == nullptr) {
                                                     return CHIP_ERROR_INVALID_ARGUMENT;
                                                 }
-                                                auto element_4 = (NSNumber *) element_2.attributeValue[i_4];
-                                                listHolder_4->mList[i_4] = element_4.unsignedCharValue;
+                                                listFreer.add(listHolder_4);
+                                                for (size_t i_4 = 0; i_4 < element_2.attributeValue.count; ++i_4) {
+                                                    if (![element_2.attributeValue[i_4] isKindOfClass:[NSNumber class]]) {
+                                                        // Wrong kind of value.
+                                                        return CHIP_ERROR_INVALID_ARGUMENT;
+                                                    }
+                                                    auto element_4 = (NSNumber *) element_2.attributeValue[i_4];
+                                                    listHolder_4->mList[i_4] = element_4.unsignedCharValue;
+                                                }
+                                                listHolder_2->mList[i_2].attributeValue
+                                                    = ListType_4(listHolder_4->mList, element_2.attributeValue.count);
+                                            } else {
+                                                listHolder_2->mList[i_2].attributeValue = ListType_4();
                                             }
-                                            listHolder_2->mList[i_2].attributeValue
-                                                = ListType_4(listHolder_4->mList, element_2.attributeValue.count);
-                                        } else {
-                                            listHolder_2->mList[i_2].attributeValue = ListType_4();
                                         }
                                     }
+                                    listHolder_0->mList[i_0].attributeValueList
+                                        = ListType_2(listHolder_2->mList, element_0.attributeValueList.count);
+                                } else {
+                                    listHolder_0->mList[i_0].attributeValueList = ListType_2();
                                 }
-                                listHolder_0->mList[i_0].attributeValueList
-                                    = ListType_2(listHolder_2->mList, element_0.attributeValueList.count);
-                            } else {
-                                listHolder_0->mList[i_0].attributeValueList = ListType_2();
                             }
                         }
+                        request.extensionFieldSets = ListType_0(listHolder_0->mList, params.extensionFieldSets.count);
+                    } else {
+                        request.extensionFieldSets = ListType_0();
                     }
-                    request.extensionFieldSets = ListType_0(listHolder_0->mList, params.extensionFieldSets.count);
-                } else {
-                    request.extensionFieldSets = ListType_0();
                 }
-            }
 
-            auto successFn = Callback<ScenesClusterAddSceneResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<ScenesClusterAddSceneResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)viewSceneWithParams:(MTRScenesClusterViewSceneParams *)params
@@ -613,27 +763,43 @@ - (void)viewSceneWithParams:(MTRScenesClusterViewSceneParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRScenesClusterViewSceneResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Scenes::Commands::ViewScene::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRScenesClusterViewSceneResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Scenes::Commands::ViewScene::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.groupId = params.groupId.unsignedShortValue;
-            request.sceneId = params.sceneId.unsignedCharValue;
-
-            auto successFn = Callback<ScenesClusterViewSceneResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.groupId = params.groupId.unsignedShortValue;
+                request.sceneId = params.sceneId.unsignedCharValue;
+
+                auto successFn = Callback<ScenesClusterViewSceneResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)removeSceneWithParams:(MTRScenesClusterRemoveSceneParams *)params
@@ -644,27 +810,43 @@ - (void)removeSceneWithParams:(MTRScenesClusterRemoveSceneParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRScenesClusterRemoveSceneResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Scenes::Commands::RemoveScene::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRScenesClusterRemoveSceneResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Scenes::Commands::RemoveScene::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.groupId = params.groupId.unsignedShortValue;
-            request.sceneId = params.sceneId.unsignedCharValue;
-
-            auto successFn = Callback<ScenesClusterRemoveSceneResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.groupId = params.groupId.unsignedShortValue;
+                request.sceneId = params.sceneId.unsignedCharValue;
+
+                auto successFn = Callback<ScenesClusterRemoveSceneResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)removeAllScenesWithParams:(MTRScenesClusterRemoveAllScenesParams *)params
@@ -675,26 +857,42 @@ - (void)removeAllScenesWithParams:(MTRScenesClusterRemoveAllScenesParams *)param
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRScenesClusterRemoveAllScenesResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Scenes::Commands::RemoveAllScenes::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRScenesClusterRemoveAllScenesResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Scenes::Commands::RemoveAllScenes::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.groupId = params.groupId.unsignedShortValue;
-
-            auto successFn = Callback<ScenesClusterRemoveAllScenesResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.groupId = params.groupId.unsignedShortValue;
+
+                auto successFn = Callback<ScenesClusterRemoveAllScenesResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)storeSceneWithParams:(MTRScenesClusterStoreSceneParams *)params
@@ -705,27 +903,43 @@ - (void)storeSceneWithParams:(MTRScenesClusterStoreSceneParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRScenesClusterStoreSceneResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Scenes::Commands::StoreScene::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRScenesClusterStoreSceneResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Scenes::Commands::StoreScene::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.groupId = params.groupId.unsignedShortValue;
-            request.sceneId = params.sceneId.unsignedCharValue;
-
-            auto successFn = Callback<ScenesClusterStoreSceneResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.groupId = params.groupId.unsignedShortValue;
+                request.sceneId = params.sceneId.unsignedCharValue;
+
+                auto successFn = Callback<ScenesClusterStoreSceneResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)recallSceneWithParams:(MTRScenesClusterRecallSceneParams *)params
@@ -735,40 +949,57 @@ - (void)recallSceneWithParams:(MTRScenesClusterRecallSceneParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Scenes::Commands::RecallScene::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.groupId = params.groupId.unsignedShortValue;
-            request.sceneId = params.sceneId.unsignedCharValue;
-            if (params.transitionTime != nil) {
-                auto & definedValue_0 = request.transitionTime.Emplace();
-                if (params.transitionTime == nil) {
-                    definedValue_0.SetNull();
-                } else {
-                    auto & nonNullValue_1 = definedValue_0.SetNonNull();
-                    nonNullValue_1 = params.transitionTime.unsignedShortValue;
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Scenes::Commands::RecallScene::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.groupId = params.groupId.unsignedShortValue;
+                request.sceneId = params.sceneId.unsignedCharValue;
+                if (params.transitionTime != nil) {
+                    auto & definedValue_0 = request.transitionTime.Emplace();
+                    if (params.transitionTime == nil) {
+                        definedValue_0.SetNull();
+                    } else {
+                        auto & nonNullValue_1 = definedValue_0.SetNonNull();
+                        nonNullValue_1 = params.transitionTime.unsignedShortValue;
+                    }
                 }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
 
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)getSceneMembershipWithParams:(MTRScenesClusterGetSceneMembershipParams *)params
@@ -779,26 +1010,42 @@ - (void)getSceneMembershipWithParams:(MTRScenesClusterGetSceneMembershipParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRScenesClusterGetSceneMembershipResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Scenes::Commands::GetSceneMembership::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRScenesClusterGetSceneMembershipResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Scenes::Commands::GetSceneMembership::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.groupId = params.groupId.unsignedShortValue;
-
-            auto successFn = Callback<ScenesClusterGetSceneMembershipResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.groupId = params.groupId.unsignedShortValue;
+
+                auto successFn = Callback<ScenesClusterGetSceneMembershipResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)enhancedAddSceneWithParams:(MTRScenesClusterEnhancedAddSceneParams *)params
@@ -809,102 +1056,119 @@ - (void)enhancedAddSceneWithParams:(MTRScenesClusterEnhancedAddSceneParams *)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRScenesClusterEnhancedAddSceneResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Scenes::Commands::EnhancedAddScene::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.groupId = params.groupId.unsignedShortValue;
-            request.sceneId = params.sceneId.unsignedCharValue;
-            request.transitionTime = params.transitionTime.unsignedShortValue;
-            request.sceneName = [self asCharSpan:params.sceneName];
-            {
-                using ListType_0 = std::remove_reference_t<decltype(request.extensionFieldSets)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (params.extensionFieldSets.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.extensionFieldSets.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < params.extensionFieldSets.count; ++i_0) {
-                        if (![params.extensionFieldSets[i_0] isKindOfClass:[MTRScenesClusterExtensionFieldSet class]]) {
-                            // Wrong kind of value.
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRScenesClusterEnhancedAddSceneResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Scenes::Commands::EnhancedAddScene::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.groupId = params.groupId.unsignedShortValue;
+                request.sceneId = params.sceneId.unsignedCharValue;
+                request.transitionTime = params.transitionTime.unsignedShortValue;
+                request.sceneName = [self asCharSpan:params.sceneName];
+                {
+                    using ListType_0 = std::remove_reference_t<decltype(request.extensionFieldSets)>;
+                    using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+                    if (params.extensionFieldSets.count != 0) {
+                        auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.extensionFieldSets.count);
+                        if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                             return CHIP_ERROR_INVALID_ARGUMENT;
                         }
-                        auto element_0 = (MTRScenesClusterExtensionFieldSet *) params.extensionFieldSets[i_0];
-                        listHolder_0->mList[i_0].clusterId = element_0.clusterId.unsignedIntValue;
-                        {
-                            using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].attributeValueList)>;
-                            using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
-                            if (element_0.attributeValueList.count != 0) {
-                                auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.attributeValueList.count);
-                                if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
-                                    return CHIP_ERROR_INVALID_ARGUMENT;
-                                }
-                                listFreer.add(listHolder_2);
-                                for (size_t i_2 = 0; i_2 < element_0.attributeValueList.count; ++i_2) {
-                                    if (![element_0.attributeValueList[i_2]
-                                            isKindOfClass:[MTRScenesClusterAttributeValuePair class]]) {
-                                        // Wrong kind of value.
+                        listFreer.add(listHolder_0);
+                        for (size_t i_0 = 0; i_0 < params.extensionFieldSets.count; ++i_0) {
+                            if (![params.extensionFieldSets[i_0] isKindOfClass:[MTRScenesClusterExtensionFieldSet class]]) {
+                                // Wrong kind of value.
+                                return CHIP_ERROR_INVALID_ARGUMENT;
+                            }
+                            auto element_0 = (MTRScenesClusterExtensionFieldSet *) params.extensionFieldSets[i_0];
+                            listHolder_0->mList[i_0].clusterId = element_0.clusterId.unsignedIntValue;
+                            {
+                                using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].attributeValueList)>;
+                                using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
+                                if (element_0.attributeValueList.count != 0) {
+                                    auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.attributeValueList.count);
+                                    if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
                                         return CHIP_ERROR_INVALID_ARGUMENT;
                                     }
-                                    auto element_2 = (MTRScenesClusterAttributeValuePair *) element_0.attributeValueList[i_2];
-                                    if (element_2.attributeId != nil) {
-                                        auto & definedValue_4 = listHolder_2->mList[i_2].attributeId.Emplace();
-                                        definedValue_4 = element_2.attributeId.unsignedIntValue;
-                                    }
-                                    {
-                                        using ListType_4
-                                            = std::remove_reference_t<decltype(listHolder_2->mList[i_2].attributeValue)>;
-                                        using ListMemberType_4 = ListMemberTypeGetter<ListType_4>::Type;
-                                        if (element_2.attributeValue.count != 0) {
-                                            auto * listHolder_4 = new ListHolder<ListMemberType_4>(element_2.attributeValue.count);
-                                            if (listHolder_4 == nullptr || listHolder_4->mList == nullptr) {
-                                                return CHIP_ERROR_INVALID_ARGUMENT;
-                                            }
-                                            listFreer.add(listHolder_4);
-                                            for (size_t i_4 = 0; i_4 < element_2.attributeValue.count; ++i_4) {
-                                                if (![element_2.attributeValue[i_4] isKindOfClass:[NSNumber class]]) {
-                                                    // Wrong kind of value.
+                                    listFreer.add(listHolder_2);
+                                    for (size_t i_2 = 0; i_2 < element_0.attributeValueList.count; ++i_2) {
+                                        if (![element_0.attributeValueList[i_2]
+                                                isKindOfClass:[MTRScenesClusterAttributeValuePair class]]) {
+                                            // Wrong kind of value.
+                                            return CHIP_ERROR_INVALID_ARGUMENT;
+                                        }
+                                        auto element_2 = (MTRScenesClusterAttributeValuePair *) element_0.attributeValueList[i_2];
+                                        if (element_2.attributeId != nil) {
+                                            auto & definedValue_4 = listHolder_2->mList[i_2].attributeId.Emplace();
+                                            definedValue_4 = element_2.attributeId.unsignedIntValue;
+                                        }
+                                        {
+                                            using ListType_4
+                                                = std::remove_reference_t<decltype(listHolder_2->mList[i_2].attributeValue)>;
+                                            using ListMemberType_4 = ListMemberTypeGetter<ListType_4>::Type;
+                                            if (element_2.attributeValue.count != 0) {
+                                                auto * listHolder_4
+                                                    = new ListHolder<ListMemberType_4>(element_2.attributeValue.count);
+                                                if (listHolder_4 == nullptr || listHolder_4->mList == nullptr) {
                                                     return CHIP_ERROR_INVALID_ARGUMENT;
                                                 }
-                                                auto element_4 = (NSNumber *) element_2.attributeValue[i_4];
-                                                listHolder_4->mList[i_4] = element_4.unsignedCharValue;
+                                                listFreer.add(listHolder_4);
+                                                for (size_t i_4 = 0; i_4 < element_2.attributeValue.count; ++i_4) {
+                                                    if (![element_2.attributeValue[i_4] isKindOfClass:[NSNumber class]]) {
+                                                        // Wrong kind of value.
+                                                        return CHIP_ERROR_INVALID_ARGUMENT;
+                                                    }
+                                                    auto element_4 = (NSNumber *) element_2.attributeValue[i_4];
+                                                    listHolder_4->mList[i_4] = element_4.unsignedCharValue;
+                                                }
+                                                listHolder_2->mList[i_2].attributeValue
+                                                    = ListType_4(listHolder_4->mList, element_2.attributeValue.count);
+                                            } else {
+                                                listHolder_2->mList[i_2].attributeValue = ListType_4();
                                             }
-                                            listHolder_2->mList[i_2].attributeValue
-                                                = ListType_4(listHolder_4->mList, element_2.attributeValue.count);
-                                        } else {
-                                            listHolder_2->mList[i_2].attributeValue = ListType_4();
                                         }
                                     }
+                                    listHolder_0->mList[i_0].attributeValueList
+                                        = ListType_2(listHolder_2->mList, element_0.attributeValueList.count);
+                                } else {
+                                    listHolder_0->mList[i_0].attributeValueList = ListType_2();
                                 }
-                                listHolder_0->mList[i_0].attributeValueList
-                                    = ListType_2(listHolder_2->mList, element_0.attributeValueList.count);
-                            } else {
-                                listHolder_0->mList[i_0].attributeValueList = ListType_2();
                             }
                         }
+                        request.extensionFieldSets = ListType_0(listHolder_0->mList, params.extensionFieldSets.count);
+                    } else {
+                        request.extensionFieldSets = ListType_0();
                     }
-                    request.extensionFieldSets = ListType_0(listHolder_0->mList, params.extensionFieldSets.count);
-                } else {
-                    request.extensionFieldSets = ListType_0();
                 }
-            }
 
-            auto successFn = Callback<ScenesClusterEnhancedAddSceneResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<ScenesClusterEnhancedAddSceneResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)enhancedViewSceneWithParams:(MTRScenesClusterEnhancedViewSceneParams *)params
@@ -915,27 +1179,43 @@ - (void)enhancedViewSceneWithParams:(MTRScenesClusterEnhancedViewSceneParams *)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRScenesClusterEnhancedViewSceneResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Scenes::Commands::EnhancedViewScene::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRScenesClusterEnhancedViewSceneResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Scenes::Commands::EnhancedViewScene::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.groupId = params.groupId.unsignedShortValue;
-            request.sceneId = params.sceneId.unsignedCharValue;
-
-            auto successFn = Callback<ScenesClusterEnhancedViewSceneResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.groupId = params.groupId.unsignedShortValue;
+                request.sceneId = params.sceneId.unsignedCharValue;
+
+                auto successFn = Callback<ScenesClusterEnhancedViewSceneResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)copySceneWithParams:(MTRScenesClusterCopySceneParams *)params
@@ -946,30 +1226,46 @@ - (void)copySceneWithParams:(MTRScenesClusterCopySceneParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRScenesClusterCopySceneResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Scenes::Commands::CopyScene::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.mode = static_cast<std::remove_reference_t<decltype(request.mode)>>(params.mode.unsignedCharValue);
-            request.groupIdFrom = params.groupIdFrom.unsignedShortValue;
-            request.sceneIdFrom = params.sceneIdFrom.unsignedCharValue;
-            request.groupIdTo = params.groupIdTo.unsignedShortValue;
-            request.sceneIdTo = params.sceneIdTo.unsignedCharValue;
-
-            auto successFn = Callback<ScenesClusterCopySceneResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRScenesClusterCopySceneResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Scenes::Commands::CopyScene::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.mode = static_cast<std::remove_reference_t<decltype(request.mode)>>(params.mode.unsignedCharValue);
+                request.groupIdFrom = params.groupIdFrom.unsignedShortValue;
+                request.sceneIdFrom = params.sceneIdFrom.unsignedCharValue;
+                request.groupIdTo = params.groupIdTo.unsignedShortValue;
+                request.sceneIdTo = params.sceneIdTo.unsignedCharValue;
+
+                auto successFn = Callback<ScenesClusterCopySceneResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeSceneCountWithParams:(MTRReadParams * _Nullable)params
@@ -1093,29 +1389,46 @@ - (void)offWithParams:(MTROnOffClusterOffParams * _Nullable)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            OnOff::Commands::Off::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                OnOff::Commands::Off::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)onWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -1134,29 +1447,46 @@ - (void)onWithParams:(MTROnOffClusterOnParams * _Nullable)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            OnOff::Commands::On::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                OnOff::Commands::On::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)toggleWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -1175,29 +1505,46 @@ - (void)toggleWithParams:(MTROnOffClusterToggleParams * _Nullable)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            OnOff::Commands::Toggle::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                OnOff::Commands::Toggle::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)offWithEffectWithParams:(MTROnOffClusterOffWithEffectParams *)params
@@ -1207,32 +1554,50 @@ - (void)offWithEffectWithParams:(MTROnOffClusterOffWithEffectParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            OnOff::Commands::OffWithEffect::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.effectId = static_cast<std::remove_reference_t<decltype(request.effectId)>>(params.effectId.unsignedCharValue);
-            request.effectVariant
-                = static_cast<std::remove_reference_t<decltype(request.effectVariant)>>(params.effectVariant.unsignedCharValue);
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                OnOff::Commands::OffWithEffect::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.effectId
+                    = static_cast<std::remove_reference_t<decltype(request.effectId)>>(params.effectId.unsignedCharValue);
+                request.effectVariant
+                    = static_cast<std::remove_reference_t<decltype(request.effectVariant)>>(params.effectVariant.unsignedCharValue);
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)onWithRecallGlobalSceneWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -1251,29 +1616,46 @@ - (void)onWithRecallGlobalSceneWithParams:(MTROnOffClusterOnWithRecallGlobalScen
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            OnOff::Commands::OnWithRecallGlobalScene::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                OnOff::Commands::OnWithRecallGlobalScene::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)onWithTimedOffWithParams:(MTROnOffClusterOnWithTimedOffParams *)params
@@ -1283,33 +1665,50 @@ - (void)onWithTimedOffWithParams:(MTROnOffClusterOnWithTimedOffParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            OnOff::Commands::OnWithTimedOff::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.onOffControl
-                = static_cast<std::remove_reference_t<decltype(request.onOffControl)>>(params.onOffControl.unsignedCharValue);
-            request.onTime = params.onTime.unsignedShortValue;
-            request.offWaitTime = params.offWaitTime.unsignedShortValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                OnOff::Commands::OnWithTimedOff::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.onOffControl
+                    = static_cast<std::remove_reference_t<decltype(request.onOffControl)>>(params.onOffControl.unsignedCharValue);
+                request.onTime = params.onTime.unsignedShortValue;
+                request.offWaitTime = params.offWaitTime.unsignedShortValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeOnOffWithParams:(MTRReadParams * _Nullable)params
@@ -1565,38 +1964,55 @@ - (void)moveToLevelWithParams:(MTRLevelControlClusterMoveToLevelParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            LevelControl::Commands::MoveToLevel::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.level = params.level.unsignedCharValue;
-            if (params.transitionTime == nil) {
-                request.transitionTime.SetNull();
-            } else {
-                auto & nonNullValue_0 = request.transitionTime.SetNonNull();
-                nonNullValue_0 = params.transitionTime.unsignedShortValue;
-            }
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                LevelControl::Commands::MoveToLevel::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.level = params.level.unsignedCharValue;
+                if (params.transitionTime == nil) {
+                    request.transitionTime.SetNull();
+                } else {
+                    auto & nonNullValue_0 = request.transitionTime.SetNonNull();
+                    nonNullValue_0 = params.transitionTime.unsignedShortValue;
+                }
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)moveWithParams:(MTRLevelControlClusterMoveParams *)params
@@ -1606,38 +2022,56 @@ - (void)moveWithParams:(MTRLevelControlClusterMoveParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            LevelControl::Commands::Move::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.moveMode = static_cast<std::remove_reference_t<decltype(request.moveMode)>>(params.moveMode.unsignedCharValue);
-            if (params.rate == nil) {
-                request.rate.SetNull();
-            } else {
-                auto & nonNullValue_0 = request.rate.SetNonNull();
-                nonNullValue_0 = params.rate.unsignedCharValue;
-            }
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                LevelControl::Commands::Move::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.moveMode
+                    = static_cast<std::remove_reference_t<decltype(request.moveMode)>>(params.moveMode.unsignedCharValue);
+                if (params.rate == nil) {
+                    request.rate.SetNull();
+                } else {
+                    auto & nonNullValue_0 = request.rate.SetNonNull();
+                    nonNullValue_0 = params.rate.unsignedCharValue;
+                }
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)stepWithParams:(MTRLevelControlClusterStepParams *)params
@@ -1647,39 +2081,57 @@ - (void)stepWithParams:(MTRLevelControlClusterStepParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            LevelControl::Commands::Step::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.stepMode = static_cast<std::remove_reference_t<decltype(request.stepMode)>>(params.stepMode.unsignedCharValue);
-            request.stepSize = params.stepSize.unsignedCharValue;
-            if (params.transitionTime == nil) {
-                request.transitionTime.SetNull();
-            } else {
-                auto & nonNullValue_0 = request.transitionTime.SetNonNull();
-                nonNullValue_0 = params.transitionTime.unsignedShortValue;
-            }
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                LevelControl::Commands::Step::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.stepMode
+                    = static_cast<std::remove_reference_t<decltype(request.stepMode)>>(params.stepMode.unsignedCharValue);
+                request.stepSize = params.stepSize.unsignedCharValue;
+                if (params.transitionTime == nil) {
+                    request.transitionTime.SetNull();
+                } else {
+                    auto & nonNullValue_0 = request.transitionTime.SetNonNull();
+                    nonNullValue_0 = params.transitionTime.unsignedShortValue;
+                }
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)stopWithParams:(MTRLevelControlClusterStopParams *)params
@@ -1689,31 +2141,48 @@ - (void)stopWithParams:(MTRLevelControlClusterStopParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            LevelControl::Commands::Stop::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                LevelControl::Commands::Stop::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)moveToLevelWithOnOffWithParams:(MTRLevelControlClusterMoveToLevelWithOnOffParams *)params
@@ -1723,38 +2192,55 @@ - (void)moveToLevelWithOnOffWithParams:(MTRLevelControlClusterMoveToLevelWithOnO
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            LevelControl::Commands::MoveToLevelWithOnOff::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.level = params.level.unsignedCharValue;
-            if (params.transitionTime == nil) {
-                request.transitionTime.SetNull();
-            } else {
-                auto & nonNullValue_0 = request.transitionTime.SetNonNull();
-                nonNullValue_0 = params.transitionTime.unsignedShortValue;
-            }
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                LevelControl::Commands::MoveToLevelWithOnOff::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.level = params.level.unsignedCharValue;
+                if (params.transitionTime == nil) {
+                    request.transitionTime.SetNull();
+                } else {
+                    auto & nonNullValue_0 = request.transitionTime.SetNonNull();
+                    nonNullValue_0 = params.transitionTime.unsignedShortValue;
+                }
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)moveWithOnOffWithParams:(MTRLevelControlClusterMoveWithOnOffParams *)params
@@ -1764,38 +2250,56 @@ - (void)moveWithOnOffWithParams:(MTRLevelControlClusterMoveWithOnOffParams *)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            LevelControl::Commands::MoveWithOnOff::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.moveMode = static_cast<std::remove_reference_t<decltype(request.moveMode)>>(params.moveMode.unsignedCharValue);
-            if (params.rate == nil) {
-                request.rate.SetNull();
-            } else {
-                auto & nonNullValue_0 = request.rate.SetNonNull();
-                nonNullValue_0 = params.rate.unsignedCharValue;
-            }
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                LevelControl::Commands::MoveWithOnOff::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.moveMode
+                    = static_cast<std::remove_reference_t<decltype(request.moveMode)>>(params.moveMode.unsignedCharValue);
+                if (params.rate == nil) {
+                    request.rate.SetNull();
+                } else {
+                    auto & nonNullValue_0 = request.rate.SetNonNull();
+                    nonNullValue_0 = params.rate.unsignedCharValue;
+                }
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)stepWithOnOffWithParams:(MTRLevelControlClusterStepWithOnOffParams *)params
@@ -1805,39 +2309,57 @@ - (void)stepWithOnOffWithParams:(MTRLevelControlClusterStepWithOnOffParams *)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            LevelControl::Commands::StepWithOnOff::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.stepMode = static_cast<std::remove_reference_t<decltype(request.stepMode)>>(params.stepMode.unsignedCharValue);
-            request.stepSize = params.stepSize.unsignedCharValue;
-            if (params.transitionTime == nil) {
-                request.transitionTime.SetNull();
-            } else {
-                auto & nonNullValue_0 = request.transitionTime.SetNonNull();
-                nonNullValue_0 = params.transitionTime.unsignedShortValue;
-            }
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                LevelControl::Commands::StepWithOnOff::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.stepMode
+                    = static_cast<std::remove_reference_t<decltype(request.stepMode)>>(params.stepMode.unsignedCharValue);
+                request.stepSize = params.stepSize.unsignedCharValue;
+                if (params.transitionTime == nil) {
+                    request.transitionTime.SetNull();
+                } else {
+                    auto & nonNullValue_0 = request.transitionTime.SetNonNull();
+                    nonNullValue_0 = params.transitionTime.unsignedShortValue;
+                }
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)stopWithOnOffWithParams:(MTRLevelControlClusterStopWithOnOffParams *)params
@@ -1847,31 +2369,48 @@ - (void)stopWithOnOffWithParams:(MTRLevelControlClusterStopWithOnOffParams *)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            LevelControl::Commands::StopWithOnOff::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                LevelControl::Commands::StopWithOnOff::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)moveToClosestFrequencyWithParams:(MTRLevelControlClusterMoveToClosestFrequencyParams *)params
@@ -1881,30 +2420,47 @@ - (void)moveToClosestFrequencyWithParams:(MTRLevelControlClusterMoveToClosestFre
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            LevelControl::Commands::MoveToClosestFrequency::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.frequency = params.frequency.unsignedShortValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                LevelControl::Commands::MoveToClosestFrequency::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.frequency = params.frequency.unsignedShortValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeCurrentLevelWithParams:(MTRReadParams * _Nullable)params
@@ -2767,34 +3323,51 @@ - (void)instantActionWithParams:(MTRActionsClusterInstantActionParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Actions::Commands::InstantAction::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.actionID = params.actionID.unsignedShortValue;
-            if (params.invokeID != nil) {
-                auto & definedValue_0 = request.invokeID.Emplace();
-                definedValue_0 = params.invokeID.unsignedIntValue;
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Actions::Commands::InstantAction::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.actionID = params.actionID.unsignedShortValue;
+                if (params.invokeID != nil) {
+                    auto & definedValue_0 = request.invokeID.Emplace();
+                    definedValue_0 = params.invokeID.unsignedIntValue;
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)instantActionWithTransitionWithParams:(MTRActionsClusterInstantActionWithTransitionParams *)params
@@ -2804,35 +3377,52 @@ - (void)instantActionWithTransitionWithParams:(MTRActionsClusterInstantActionWit
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Actions::Commands::InstantActionWithTransition::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.actionID = params.actionID.unsignedShortValue;
-            if (params.invokeID != nil) {
-                auto & definedValue_0 = request.invokeID.Emplace();
-                definedValue_0 = params.invokeID.unsignedIntValue;
-            }
-            request.transitionTime = params.transitionTime.unsignedShortValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Actions::Commands::InstantActionWithTransition::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.actionID = params.actionID.unsignedShortValue;
+                if (params.invokeID != nil) {
+                    auto & definedValue_0 = request.invokeID.Emplace();
+                    definedValue_0 = params.invokeID.unsignedIntValue;
+                }
+                request.transitionTime = params.transitionTime.unsignedShortValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)startActionWithParams:(MTRActionsClusterStartActionParams *)params
@@ -2842,34 +3432,51 @@ - (void)startActionWithParams:(MTRActionsClusterStartActionParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Actions::Commands::StartAction::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.actionID = params.actionID.unsignedShortValue;
-            if (params.invokeID != nil) {
-                auto & definedValue_0 = request.invokeID.Emplace();
-                definedValue_0 = params.invokeID.unsignedIntValue;
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Actions::Commands::StartAction::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.actionID = params.actionID.unsignedShortValue;
+                if (params.invokeID != nil) {
+                    auto & definedValue_0 = request.invokeID.Emplace();
+                    definedValue_0 = params.invokeID.unsignedIntValue;
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)startActionWithDurationWithParams:(MTRActionsClusterStartActionWithDurationParams *)params
@@ -2879,35 +3486,52 @@ - (void)startActionWithDurationWithParams:(MTRActionsClusterStartActionWithDurat
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Actions::Commands::StartActionWithDuration::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.actionID = params.actionID.unsignedShortValue;
-            if (params.invokeID != nil) {
-                auto & definedValue_0 = request.invokeID.Emplace();
-                definedValue_0 = params.invokeID.unsignedIntValue;
-            }
-            request.duration = params.duration.unsignedIntValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Actions::Commands::StartActionWithDuration::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.actionID = params.actionID.unsignedShortValue;
+                if (params.invokeID != nil) {
+                    auto & definedValue_0 = request.invokeID.Emplace();
+                    definedValue_0 = params.invokeID.unsignedIntValue;
+                }
+                request.duration = params.duration.unsignedIntValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)stopActionWithParams:(MTRActionsClusterStopActionParams *)params
@@ -2917,35 +3541,52 @@ - (void)stopActionWithParams:(MTRActionsClusterStopActionParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Actions::Commands::StopAction::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.actionID = params.actionID.unsignedShortValue;
-            if (params.invokeID != nil) {
-                auto & definedValue_0 = request.invokeID.Emplace();
-                definedValue_0 = params.invokeID.unsignedIntValue;
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
-}
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Actions::Commands::StopAction::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.actionID = params.actionID.unsignedShortValue;
+                if (params.invokeID != nil) {
+                    auto & definedValue_0 = request.invokeID.Emplace();
+                    definedValue_0 = params.invokeID.unsignedIntValue;
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
+}
 
 - (void)pauseActionWithParams:(MTRActionsClusterPauseActionParams *)params
                expectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -2954,34 +3595,51 @@ - (void)pauseActionWithParams:(MTRActionsClusterPauseActionParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Actions::Commands::PauseAction::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.actionID = params.actionID.unsignedShortValue;
-            if (params.invokeID != nil) {
-                auto & definedValue_0 = request.invokeID.Emplace();
-                definedValue_0 = params.invokeID.unsignedIntValue;
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Actions::Commands::PauseAction::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.actionID = params.actionID.unsignedShortValue;
+                if (params.invokeID != nil) {
+                    auto & definedValue_0 = request.invokeID.Emplace();
+                    definedValue_0 = params.invokeID.unsignedIntValue;
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)pauseActionWithDurationWithParams:(MTRActionsClusterPauseActionWithDurationParams *)params
@@ -2991,35 +3649,52 @@ - (void)pauseActionWithDurationWithParams:(MTRActionsClusterPauseActionWithDurat
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Actions::Commands::PauseActionWithDuration::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.actionID = params.actionID.unsignedShortValue;
-            if (params.invokeID != nil) {
-                auto & definedValue_0 = request.invokeID.Emplace();
-                definedValue_0 = params.invokeID.unsignedIntValue;
-            }
-            request.duration = params.duration.unsignedIntValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Actions::Commands::PauseActionWithDuration::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.actionID = params.actionID.unsignedShortValue;
+                if (params.invokeID != nil) {
+                    auto & definedValue_0 = request.invokeID.Emplace();
+                    definedValue_0 = params.invokeID.unsignedIntValue;
+                }
+                request.duration = params.duration.unsignedIntValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)resumeActionWithParams:(MTRActionsClusterResumeActionParams *)params
@@ -3029,34 +3704,51 @@ - (void)resumeActionWithParams:(MTRActionsClusterResumeActionParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Actions::Commands::ResumeAction::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.actionID = params.actionID.unsignedShortValue;
-            if (params.invokeID != nil) {
-                auto & definedValue_0 = request.invokeID.Emplace();
-                definedValue_0 = params.invokeID.unsignedIntValue;
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Actions::Commands::ResumeAction::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.actionID = params.actionID.unsignedShortValue;
+                if (params.invokeID != nil) {
+                    auto & definedValue_0 = request.invokeID.Emplace();
+                    definedValue_0 = params.invokeID.unsignedIntValue;
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)enableActionWithParams:(MTRActionsClusterEnableActionParams *)params
@@ -3066,34 +3758,51 @@ - (void)enableActionWithParams:(MTRActionsClusterEnableActionParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Actions::Commands::EnableAction::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.actionID = params.actionID.unsignedShortValue;
-            if (params.invokeID != nil) {
-                auto & definedValue_0 = request.invokeID.Emplace();
-                definedValue_0 = params.invokeID.unsignedIntValue;
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Actions::Commands::EnableAction::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.actionID = params.actionID.unsignedShortValue;
+                if (params.invokeID != nil) {
+                    auto & definedValue_0 = request.invokeID.Emplace();
+                    definedValue_0 = params.invokeID.unsignedIntValue;
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)enableActionWithDurationWithParams:(MTRActionsClusterEnableActionWithDurationParams *)params
@@ -3103,35 +3812,52 @@ - (void)enableActionWithDurationWithParams:(MTRActionsClusterEnableActionWithDur
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Actions::Commands::EnableActionWithDuration::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.actionID = params.actionID.unsignedShortValue;
-            if (params.invokeID != nil) {
-                auto & definedValue_0 = request.invokeID.Emplace();
-                definedValue_0 = params.invokeID.unsignedIntValue;
-            }
-            request.duration = params.duration.unsignedIntValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Actions::Commands::EnableActionWithDuration::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.actionID = params.actionID.unsignedShortValue;
+                if (params.invokeID != nil) {
+                    auto & definedValue_0 = request.invokeID.Emplace();
+                    definedValue_0 = params.invokeID.unsignedIntValue;
+                }
+                request.duration = params.duration.unsignedIntValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)disableActionWithParams:(MTRActionsClusterDisableActionParams *)params
@@ -3141,34 +3867,51 @@ - (void)disableActionWithParams:(MTRActionsClusterDisableActionParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Actions::Commands::DisableAction::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.actionID = params.actionID.unsignedShortValue;
-            if (params.invokeID != nil) {
-                auto & definedValue_0 = request.invokeID.Emplace();
-                definedValue_0 = params.invokeID.unsignedIntValue;
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Actions::Commands::DisableAction::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.actionID = params.actionID.unsignedShortValue;
+                if (params.invokeID != nil) {
+                    auto & definedValue_0 = request.invokeID.Emplace();
+                    definedValue_0 = params.invokeID.unsignedIntValue;
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)disableActionWithDurationWithParams:(MTRActionsClusterDisableActionWithDurationParams *)params
@@ -3178,35 +3921,52 @@ - (void)disableActionWithDurationWithParams:(MTRActionsClusterDisableActionWithD
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Actions::Commands::DisableActionWithDuration::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.actionID = params.actionID.unsignedShortValue;
-            if (params.invokeID != nil) {
-                auto & definedValue_0 = request.invokeID.Emplace();
-                definedValue_0 = params.invokeID.unsignedIntValue;
-            }
-            request.duration = params.duration.unsignedIntValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Actions::Commands::DisableActionWithDuration::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.actionID = params.actionID.unsignedShortValue;
+                if (params.invokeID != nil) {
+                    auto & definedValue_0 = request.invokeID.Emplace();
+                    definedValue_0 = params.invokeID.unsignedIntValue;
+                }
+                request.duration = params.duration.unsignedIntValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeActionListWithParams:(MTRReadParams * _Nullable)params
@@ -3306,29 +4066,46 @@ - (void)mfgSpecificPingWithParams:(MTRBasicClusterMfgSpecificPingParams * _Nulla
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Basic::Commands::MfgSpecificPing::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Basic::Commands::MfgSpecificPing::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeDataModelRevisionWithParams:(MTRReadParams * _Nullable)params
@@ -3613,67 +4390,84 @@ - (void)queryImageWithParams:(MTROtaSoftwareUpdateProviderClusterQueryImageParam
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTROtaSoftwareUpdateProviderClusterQueryImageResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            OtaSoftwareUpdateProvider::Commands::QueryImage::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.vendorId = static_cast<std::remove_reference_t<decltype(request.vendorId)>>(params.vendorId.unsignedShortValue);
-            request.productId = params.productId.unsignedShortValue;
-            request.softwareVersion = params.softwareVersion.unsignedIntValue;
-            {
-                using ListType_0 = std::remove_reference_t<decltype(request.protocolsSupported)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (params.protocolsSupported.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.protocolsSupported.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < params.protocolsSupported.count; ++i_0) {
-                        if (![params.protocolsSupported[i_0] isKindOfClass:[NSNumber class]]) {
-                            // Wrong kind of value.
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTROtaSoftwareUpdateProviderClusterQueryImageResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                OtaSoftwareUpdateProvider::Commands::QueryImage::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.vendorId
+                    = static_cast<std::remove_reference_t<decltype(request.vendorId)>>(params.vendorId.unsignedShortValue);
+                request.productId = params.productId.unsignedShortValue;
+                request.softwareVersion = params.softwareVersion.unsignedIntValue;
+                {
+                    using ListType_0 = std::remove_reference_t<decltype(request.protocolsSupported)>;
+                    using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+                    if (params.protocolsSupported.count != 0) {
+                        auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.protocolsSupported.count);
+                        if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                             return CHIP_ERROR_INVALID_ARGUMENT;
                         }
-                        auto element_0 = (NSNumber *) params.protocolsSupported[i_0];
-                        listHolder_0->mList[i_0]
-                            = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0])>>(element_0.unsignedCharValue);
+                        listFreer.add(listHolder_0);
+                        for (size_t i_0 = 0; i_0 < params.protocolsSupported.count; ++i_0) {
+                            if (![params.protocolsSupported[i_0] isKindOfClass:[NSNumber class]]) {
+                                // Wrong kind of value.
+                                return CHIP_ERROR_INVALID_ARGUMENT;
+                            }
+                            auto element_0 = (NSNumber *) params.protocolsSupported[i_0];
+                            listHolder_0->mList[i_0] = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0])>>(
+                                element_0.unsignedCharValue);
+                        }
+                        request.protocolsSupported = ListType_0(listHolder_0->mList, params.protocolsSupported.count);
+                    } else {
+                        request.protocolsSupported = ListType_0();
                     }
-                    request.protocolsSupported = ListType_0(listHolder_0->mList, params.protocolsSupported.count);
-                } else {
-                    request.protocolsSupported = ListType_0();
-                }
-            }
-            if (params.hardwareVersion != nil) {
-                auto & definedValue_0 = request.hardwareVersion.Emplace();
-                definedValue_0 = params.hardwareVersion.unsignedShortValue;
-            }
-            if (params.location != nil) {
-                auto & definedValue_0 = request.location.Emplace();
-                definedValue_0 = [self asCharSpan:params.location];
-            }
-            if (params.requestorCanConsent != nil) {
-                auto & definedValue_0 = request.requestorCanConsent.Emplace();
-                definedValue_0 = params.requestorCanConsent.boolValue;
-            }
-            if (params.metadataForProvider != nil) {
-                auto & definedValue_0 = request.metadataForProvider.Emplace();
-                definedValue_0 = [self asByteSpan:params.metadataForProvider];
-            }
-
-            auto successFn = Callback<OtaSoftwareUpdateProviderClusterQueryImageResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                }
+                if (params.hardwareVersion != nil) {
+                    auto & definedValue_0 = request.hardwareVersion.Emplace();
+                    definedValue_0 = params.hardwareVersion.unsignedShortValue;
+                }
+                if (params.location != nil) {
+                    auto & definedValue_0 = request.location.Emplace();
+                    definedValue_0 = [self asCharSpan:params.location];
+                }
+                if (params.requestorCanConsent != nil) {
+                    auto & definedValue_0 = request.requestorCanConsent.Emplace();
+                    definedValue_0 = params.requestorCanConsent.boolValue;
+                }
+                if (params.metadataForProvider != nil) {
+                    auto & definedValue_0 = request.metadataForProvider.Emplace();
+                    definedValue_0 = [self asByteSpan:params.metadataForProvider];
+                }
+
+                auto successFn = Callback<OtaSoftwareUpdateProviderClusterQueryImageResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)applyUpdateRequestWithParams:(MTROtaSoftwareUpdateProviderClusterApplyUpdateRequestParams *)params
@@ -3684,27 +4478,43 @@ - (void)applyUpdateRequestWithParams:(MTROtaSoftwareUpdateProviderClusterApplyUp
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTROtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            OtaSoftwareUpdateProvider::Commands::ApplyUpdateRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTROtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                OtaSoftwareUpdateProvider::Commands::ApplyUpdateRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.updateToken = [self asByteSpan:params.updateToken];
-            request.newVersion = params.newVersion.unsignedIntValue;
-
-            auto successFn = Callback<OtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.updateToken = [self asByteSpan:params.updateToken];
+                request.newVersion = params.newVersion.unsignedIntValue;
+
+                auto successFn = Callback<OtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)notifyUpdateAppliedWithParams:(MTROtaSoftwareUpdateProviderClusterNotifyUpdateAppliedParams *)params
@@ -3714,31 +4524,48 @@ - (void)notifyUpdateAppliedWithParams:(MTROtaSoftwareUpdateProviderClusterNotify
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            OtaSoftwareUpdateProvider::Commands::NotifyUpdateApplied::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.updateToken = [self asByteSpan:params.updateToken];
-            request.softwareVersion = params.softwareVersion.unsignedIntValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                OtaSoftwareUpdateProvider::Commands::NotifyUpdateApplied::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.updateToken = [self asByteSpan:params.updateToken];
+                request.softwareVersion = params.softwareVersion.unsignedIntValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
@@ -3805,38 +4632,56 @@ - (void)announceOtaProviderWithParams:(MTROtaSoftwareUpdateRequestorClusterAnnou
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            OtaSoftwareUpdateRequestor::Commands::AnnounceOtaProvider::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.providerNodeId = params.providerNodeId.unsignedLongLongValue;
-            request.vendorId = static_cast<std::remove_reference_t<decltype(request.vendorId)>>(params.vendorId.unsignedShortValue);
-            request.announcementReason = static_cast<std::remove_reference_t<decltype(request.announcementReason)>>(
-                params.announcementReason.unsignedCharValue);
-            if (params.metadataForNode != nil) {
-                auto & definedValue_0 = request.metadataForNode.Emplace();
-                definedValue_0 = [self asByteSpan:params.metadataForNode];
-            }
-            request.endpoint = params.endpoint.unsignedShortValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                OtaSoftwareUpdateRequestor::Commands::AnnounceOtaProvider::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.providerNodeId = params.providerNodeId.unsignedLongLongValue;
+                request.vendorId
+                    = static_cast<std::remove_reference_t<decltype(request.vendorId)>>(params.vendorId.unsignedShortValue);
+                request.announcementReason = static_cast<std::remove_reference_t<decltype(request.announcementReason)>>(
+                    params.announcementReason.unsignedCharValue);
+                if (params.metadataForNode != nil) {
+                    auto & definedValue_0 = request.metadataForNode.Emplace();
+                    definedValue_0 = [self asByteSpan:params.metadataForNode];
+                }
+                request.endpoint = params.endpoint.unsignedShortValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeDefaultOtaProvidersWithParams:(MTRReadParams * _Nullable)params
@@ -4620,27 +5465,43 @@ - (void)armFailSafeWithParams:(MTRGeneralCommissioningClusterArmFailSafeParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRGeneralCommissioningClusterArmFailSafeResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            GeneralCommissioning::Commands::ArmFailSafe::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRGeneralCommissioningClusterArmFailSafeResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                GeneralCommissioning::Commands::ArmFailSafe::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.expiryLengthSeconds = params.expiryLengthSeconds.unsignedShortValue;
-            request.breadcrumb = params.breadcrumb.unsignedLongLongValue;
-
-            auto successFn = Callback<GeneralCommissioningClusterArmFailSafeResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.expiryLengthSeconds = params.expiryLengthSeconds.unsignedShortValue;
+                request.breadcrumb = params.breadcrumb.unsignedLongLongValue;
+
+                auto successFn = Callback<GeneralCommissioningClusterArmFailSafeResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)setRegulatoryConfigWithParams:(MTRGeneralCommissioningClusterSetRegulatoryConfigParams *)params
@@ -4651,29 +5512,47 @@ - (void)setRegulatoryConfigWithParams:(MTRGeneralCommissioningClusterSetRegulato
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            GeneralCommissioning::Commands::SetRegulatoryConfig::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.newRegulatoryConfig = static_cast<std::remove_reference_t<decltype(request.newRegulatoryConfig)>>(
-                params.newRegulatoryConfig.unsignedCharValue);
-            request.countryCode = [self asCharSpan:params.countryCode];
-            request.breadcrumb = params.breadcrumb.unsignedLongLongValue;
-
-            auto successFn = Callback<GeneralCommissioningClusterSetRegulatoryConfigResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackBridge(self.callbackQueue, baseDevice,
+            completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                GeneralCommissioning::Commands::SetRegulatoryConfig::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.newRegulatoryConfig = static_cast<std::remove_reference_t<decltype(request.newRegulatoryConfig)>>(
+                    params.newRegulatoryConfig.unsignedCharValue);
+                request.countryCode = [self asCharSpan:params.countryCode];
+                request.breadcrumb = params.breadcrumb.unsignedLongLongValue;
+
+                auto successFn
+                    = Callback<GeneralCommissioningClusterSetRegulatoryConfigResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)commissioningCompleteWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -4696,26 +5575,43 @@ - (void)commissioningCompleteWithParams:(MTRGeneralCommissioningClusterCommissio
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRGeneralCommissioningClusterCommissioningCompleteResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            GeneralCommissioning::Commands::CommissioningComplete::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRGeneralCommissioningClusterCommissioningCompleteResponseCallbackBridge(self.callbackQueue, baseDevice,
+            completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                GeneralCommissioning::Commands::CommissioningComplete::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
 
-            auto successFn
-                = Callback<GeneralCommissioningClusterCommissioningCompleteResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn
+                    = Callback<GeneralCommissioningClusterCommissioningCompleteResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeBreadcrumbWithParams:(MTRReadParams * _Nullable)params
@@ -4842,40 +5738,56 @@ - (void)scanNetworksWithParams:(MTRNetworkCommissioningClusterScanNetworksParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRNetworkCommissioningClusterScanNetworksResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            NetworkCommissioning::Commands::ScanNetworks::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            if (params != nil) {
-                if (params.ssid != nil) {
-                    auto & definedValue_0 = request.ssid.Emplace();
-                    if (params.ssid == nil) {
-                        definedValue_0.SetNull();
-                    } else {
-                        auto & nonNullValue_1 = definedValue_0.SetNonNull();
-                        nonNullValue_1 = [self asByteSpan:params.ssid];
-                    }
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRNetworkCommissioningClusterScanNetworksResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                NetworkCommissioning::Commands::ScanNetworks::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-                if (params.breadcrumb != nil) {
-                    auto & definedValue_0 = request.breadcrumb.Emplace();
-                    definedValue_0 = params.breadcrumb.unsignedLongLongValue;
+                if (params != nil) {
+                    if (params.ssid != nil) {
+                        auto & definedValue_0 = request.ssid.Emplace();
+                        if (params.ssid == nil) {
+                            definedValue_0.SetNull();
+                        } else {
+                            auto & nonNullValue_1 = definedValue_0.SetNonNull();
+                            nonNullValue_1 = [self asByteSpan:params.ssid];
+                        }
+                    }
+                    if (params.breadcrumb != nil) {
+                        auto & definedValue_0 = request.breadcrumb.Emplace();
+                        definedValue_0 = params.breadcrumb.unsignedLongLongValue;
+                    }
                 }
-            }
-
-            auto successFn = Callback<NetworkCommissioningClusterScanNetworksResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
 
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<NetworkCommissioningClusterScanNetworksResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)addOrUpdateWiFiNetworkWithParams:(MTRNetworkCommissioningClusterAddOrUpdateWiFiNetworkParams *)params
@@ -4886,31 +5798,47 @@ - (void)addOrUpdateWiFiNetworkWithParams:(MTRNetworkCommissioningClusterAddOrUpd
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            NetworkCommissioning::Commands::AddOrUpdateWiFiNetwork::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.ssid = [self asByteSpan:params.ssid];
-            request.credentials = [self asByteSpan:params.credentials];
-            if (params.breadcrumb != nil) {
-                auto & definedValue_0 = request.breadcrumb.Emplace();
-                definedValue_0 = params.breadcrumb.unsignedLongLongValue;
-            }
-
-            auto successFn = Callback<NetworkCommissioningClusterNetworkConfigResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                NetworkCommissioning::Commands::AddOrUpdateWiFiNetwork::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.ssid = [self asByteSpan:params.ssid];
+                request.credentials = [self asByteSpan:params.credentials];
+                if (params.breadcrumb != nil) {
+                    auto & definedValue_0 = request.breadcrumb.Emplace();
+                    definedValue_0 = params.breadcrumb.unsignedLongLongValue;
+                }
+
+                auto successFn = Callback<NetworkCommissioningClusterNetworkConfigResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)addOrUpdateThreadNetworkWithParams:(MTRNetworkCommissioningClusterAddOrUpdateThreadNetworkParams *)params
@@ -4921,30 +5849,46 @@ - (void)addOrUpdateThreadNetworkWithParams:(MTRNetworkCommissioningClusterAddOrU
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            NetworkCommissioning::Commands::AddOrUpdateThreadNetwork::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.operationalDataset = [self asByteSpan:params.operationalDataset];
-            if (params.breadcrumb != nil) {
-                auto & definedValue_0 = request.breadcrumb.Emplace();
-                definedValue_0 = params.breadcrumb.unsignedLongLongValue;
-            }
-
-            auto successFn = Callback<NetworkCommissioningClusterNetworkConfigResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                NetworkCommissioning::Commands::AddOrUpdateThreadNetwork::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.operationalDataset = [self asByteSpan:params.operationalDataset];
+                if (params.breadcrumb != nil) {
+                    auto & definedValue_0 = request.breadcrumb.Emplace();
+                    definedValue_0 = params.breadcrumb.unsignedLongLongValue;
+                }
+
+                auto successFn = Callback<NetworkCommissioningClusterNetworkConfigResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)removeNetworkWithParams:(MTRNetworkCommissioningClusterRemoveNetworkParams *)params
@@ -4955,30 +5899,46 @@ - (void)removeNetworkWithParams:(MTRNetworkCommissioningClusterRemoveNetworkPara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            NetworkCommissioning::Commands::RemoveNetwork::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.networkID = [self asByteSpan:params.networkID];
-            if (params.breadcrumb != nil) {
-                auto & definedValue_0 = request.breadcrumb.Emplace();
-                definedValue_0 = params.breadcrumb.unsignedLongLongValue;
-            }
-
-            auto successFn = Callback<NetworkCommissioningClusterNetworkConfigResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                NetworkCommissioning::Commands::RemoveNetwork::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.networkID = [self asByteSpan:params.networkID];
+                if (params.breadcrumb != nil) {
+                    auto & definedValue_0 = request.breadcrumb.Emplace();
+                    definedValue_0 = params.breadcrumb.unsignedLongLongValue;
+                }
+
+                auto successFn = Callback<NetworkCommissioningClusterNetworkConfigResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)connectNetworkWithParams:(MTRNetworkCommissioningClusterConnectNetworkParams *)params
@@ -4989,30 +5949,46 @@ - (void)connectNetworkWithParams:(MTRNetworkCommissioningClusterConnectNetworkPa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRNetworkCommissioningClusterConnectNetworkResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            NetworkCommissioning::Commands::ConnectNetwork::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.networkID = [self asByteSpan:params.networkID];
-            if (params.breadcrumb != nil) {
-                auto & definedValue_0 = request.breadcrumb.Emplace();
-                definedValue_0 = params.breadcrumb.unsignedLongLongValue;
-            }
-
-            auto successFn = Callback<NetworkCommissioningClusterConnectNetworkResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRNetworkCommissioningClusterConnectNetworkResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                NetworkCommissioning::Commands::ConnectNetwork::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.networkID = [self asByteSpan:params.networkID];
+                if (params.breadcrumb != nil) {
+                    auto & definedValue_0 = request.breadcrumb.Emplace();
+                    definedValue_0 = params.breadcrumb.unsignedLongLongValue;
+                }
+
+                auto successFn = Callback<NetworkCommissioningClusterConnectNetworkResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)reorderNetworkWithParams:(MTRNetworkCommissioningClusterReorderNetworkParams *)params
@@ -5023,31 +5999,47 @@ - (void)reorderNetworkWithParams:(MTRNetworkCommissioningClusterReorderNetworkPa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            NetworkCommissioning::Commands::ReorderNetwork::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.networkID = [self asByteSpan:params.networkID];
-            request.networkIndex = params.networkIndex.unsignedCharValue;
-            if (params.breadcrumb != nil) {
-                auto & definedValue_0 = request.breadcrumb.Emplace();
-                definedValue_0 = params.breadcrumb.unsignedLongLongValue;
-            }
-
-            auto successFn = Callback<NetworkCommissioningClusterNetworkConfigResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                NetworkCommissioning::Commands::ReorderNetwork::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.networkID = [self asByteSpan:params.networkID];
+                request.networkIndex = params.networkIndex.unsignedCharValue;
+                if (params.breadcrumb != nil) {
+                    auto & definedValue_0 = request.breadcrumb.Emplace();
+                    definedValue_0 = params.breadcrumb.unsignedLongLongValue;
+                }
+
+                auto successFn = Callback<NetworkCommissioningClusterNetworkConfigResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeMaxNetworksWithParams:(MTRReadParams * _Nullable)params
@@ -5198,29 +6190,45 @@ - (void)retrieveLogsRequestWithParams:(MTRDiagnosticLogsClusterRetrieveLogsReque
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRDiagnosticLogsClusterRetrieveLogsResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            DiagnosticLogs::Commands::RetrieveLogsRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.intent = static_cast<std::remove_reference_t<decltype(request.intent)>>(params.intent.unsignedCharValue);
-            request.requestedProtocol = static_cast<std::remove_reference_t<decltype(request.requestedProtocol)>>(
-                params.requestedProtocol.unsignedCharValue);
-            request.transferFileDesignator = [self asByteSpan:params.transferFileDesignator];
-
-            auto successFn = Callback<DiagnosticLogsClusterRetrieveLogsResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRDiagnosticLogsClusterRetrieveLogsResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                DiagnosticLogs::Commands::RetrieveLogsRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.intent = static_cast<std::remove_reference_t<decltype(request.intent)>>(params.intent.unsignedCharValue);
+                request.requestedProtocol = static_cast<std::remove_reference_t<decltype(request.requestedProtocol)>>(
+                    params.requestedProtocol.unsignedCharValue);
+                request.transferFileDesignator = [self asByteSpan:params.transferFileDesignator];
+
+                auto successFn = Callback<DiagnosticLogsClusterRetrieveLogsResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
@@ -5287,31 +6295,48 @@ - (void)testEventTriggerWithParams:(MTRGeneralDiagnosticsClusterTestEventTrigger
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            GeneralDiagnostics::Commands::TestEventTrigger::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.enableKey = [self asByteSpan:params.enableKey];
-            request.eventTrigger = params.eventTrigger.unsignedLongLongValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                GeneralDiagnostics::Commands::TestEventTrigger::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.enableKey = [self asByteSpan:params.enableKey];
+                request.eventTrigger = params.eventTrigger.unsignedLongLongValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeNetworkInterfacesWithParams:(MTRReadParams * _Nullable)params
@@ -5459,29 +6484,46 @@ - (void)resetWatermarksWithParams:(MTRSoftwareDiagnosticsClusterResetWatermarksP
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            SoftwareDiagnostics::Commands::ResetWatermarks::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                SoftwareDiagnostics::Commands::ResetWatermarks::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeThreadMetricsWithParams:(MTRReadParams * _Nullable)params
@@ -5589,29 +6631,46 @@ - (void)resetCountsWithParams:(MTRThreadNetworkDiagnosticsClusterResetCountsPara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ThreadNetworkDiagnostics::Commands::ResetCounts::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ThreadNetworkDiagnostics::Commands::ResetCounts::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeChannelWithParams:(MTRReadParams * _Nullable)params
@@ -6192,29 +7251,46 @@ - (void)resetCountsWithParams:(MTRWiFiNetworkDiagnosticsClusterResetCountsParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            WiFiNetworkDiagnostics::Commands::ResetCounts::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                WiFiNetworkDiagnostics::Commands::ResetCounts::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeBssidWithParams:(MTRReadParams * _Nullable)params
@@ -6394,29 +7470,46 @@ - (void)resetCountsWithParams:(MTREthernetNetworkDiagnosticsClusterResetCountsPa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            EthernetNetworkDiagnostics::Commands::ResetCounts::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                EthernetNetworkDiagnostics::Commands::ResetCounts::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributePHYRateWithParams:(MTRReadParams * _Nullable)params
@@ -6832,37 +7925,54 @@ - (void)openCommissioningWindowWithParams:(MTRAdministratorCommissioningClusterO
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            AdministratorCommissioning::Commands::OpenCommissioningWindow::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            if (!timedInvokeTimeoutMs.HasValue()) {
-                timedInvokeTimeoutMs.SetValue(10000);
-            }
-            request.commissioningTimeout = params.commissioningTimeout.unsignedShortValue;
-            request.PAKEVerifier = [self asByteSpan:params.pakeVerifier];
-            request.discriminator = params.discriminator.unsignedShortValue;
-            request.iterations = params.iterations.unsignedIntValue;
-            request.salt = [self asByteSpan:params.salt];
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                AdministratorCommissioning::Commands::OpenCommissioningWindow::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                if (!timedInvokeTimeoutMs.HasValue()) {
+                    timedInvokeTimeoutMs.SetValue(10000);
+                }
+                request.commissioningTimeout = params.commissioningTimeout.unsignedShortValue;
+                request.PAKEVerifier = [self asByteSpan:params.pakeVerifier];
+                request.discriminator = params.discriminator.unsignedShortValue;
+                request.iterations = params.iterations.unsignedIntValue;
+                request.salt = [self asByteSpan:params.salt];
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)openBasicCommissioningWindowWithParams:(MTRAdministratorCommissioningClusterOpenBasicCommissioningWindowParams *)params
@@ -6872,33 +7982,50 @@ - (void)openBasicCommissioningWindowWithParams:(MTRAdministratorCommissioningClu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            AdministratorCommissioning::Commands::OpenBasicCommissioningWindow::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            if (!timedInvokeTimeoutMs.HasValue()) {
-                timedInvokeTimeoutMs.SetValue(10000);
-            }
-            request.commissioningTimeout = params.commissioningTimeout.unsignedShortValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                AdministratorCommissioning::Commands::OpenBasicCommissioningWindow::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                if (!timedInvokeTimeoutMs.HasValue()) {
+                    timedInvokeTimeoutMs.SetValue(10000);
+                }
+                request.commissioningTimeout = params.commissioningTimeout.unsignedShortValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)revokeCommissioningWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -6917,32 +8044,49 @@ - (void)revokeCommissioningWithParams:(MTRAdministratorCommissioningClusterRevok
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            AdministratorCommissioning::Commands::RevokeCommissioning::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            if (!timedInvokeTimeoutMs.HasValue()) {
-                timedInvokeTimeoutMs.SetValue(10000);
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                AdministratorCommissioning::Commands::RevokeCommissioning::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                if (!timedInvokeTimeoutMs.HasValue()) {
+                    timedInvokeTimeoutMs.SetValue(10000);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeWindowStatusWithParams:(MTRReadParams * _Nullable)params
@@ -7034,26 +8178,42 @@ - (void)attestationRequestWithParams:(MTROperationalCredentialsClusterAttestatio
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTROperationalCredentialsClusterAttestationResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            OperationalCredentials::Commands::AttestationRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTROperationalCredentialsClusterAttestationResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                OperationalCredentials::Commands::AttestationRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.attestationNonce = [self asByteSpan:params.attestationNonce];
-
-            auto successFn = Callback<OperationalCredentialsClusterAttestationResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.attestationNonce = [self asByteSpan:params.attestationNonce];
+
+                auto successFn = Callback<OperationalCredentialsClusterAttestationResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)certificateChainRequestWithParams:(MTROperationalCredentialsClusterCertificateChainRequestParams *)params
@@ -7064,26 +8224,44 @@ - (void)certificateChainRequestWithParams:(MTROperationalCredentialsClusterCerti
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTROperationalCredentialsClusterCertificateChainResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            OperationalCredentials::Commands::CertificateChainRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTROperationalCredentialsClusterCertificateChainResponseCallbackBridge(self.callbackQueue, baseDevice,
+            completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                OperationalCredentials::Commands::CertificateChainRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.certificateType = params.certificateType.unsignedCharValue;
-
-            auto successFn = Callback<OperationalCredentialsClusterCertificateChainResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.certificateType = params.certificateType.unsignedCharValue;
+
+                auto successFn
+                    = Callback<OperationalCredentialsClusterCertificateChainResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)CSRRequestWithParams:(MTROperationalCredentialsClusterCSRRequestParams *)params
@@ -7094,30 +8272,46 @@ - (void)CSRRequestWithParams:(MTROperationalCredentialsClusterCSRRequestParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTROperationalCredentialsClusterCSRResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            OperationalCredentials::Commands::CSRRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.CSRNonce = [self asByteSpan:params.csrNonce];
-            if (params.isForUpdateNOC != nil) {
-                auto & definedValue_0 = request.isForUpdateNOC.Emplace();
-                definedValue_0 = params.isForUpdateNOC.boolValue;
-            }
-
-            auto successFn = Callback<OperationalCredentialsClusterCSRResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTROperationalCredentialsClusterCSRResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                OperationalCredentials::Commands::CSRRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.CSRNonce = [self asByteSpan:params.csrNonce];
+                if (params.isForUpdateNOC != nil) {
+                    auto & definedValue_0 = request.isForUpdateNOC.Emplace();
+                    definedValue_0 = params.isForUpdateNOC.boolValue;
+                }
+
+                auto successFn = Callback<OperationalCredentialsClusterCSRResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)addNOCWithParams:(MTROperationalCredentialsClusterAddNOCParams *)params
@@ -7128,34 +8322,50 @@ - (void)addNOCWithParams:(MTROperationalCredentialsClusterAddNOCParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            OperationalCredentials::Commands::AddNOC::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.NOCValue = [self asByteSpan:params.nocValue];
-            if (params.icacValue != nil) {
-                auto & definedValue_0 = request.ICACValue.Emplace();
-                definedValue_0 = [self asByteSpan:params.icacValue];
-            }
-            request.IPKValue = [self asByteSpan:params.ipkValue];
-            request.caseAdminSubject = params.caseAdminSubject.unsignedLongLongValue;
-            request.adminVendorId
-                = static_cast<std::remove_reference_t<decltype(request.adminVendorId)>>(params.adminVendorId.unsignedShortValue);
-
-            auto successFn = Callback<OperationalCredentialsClusterNOCResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                OperationalCredentials::Commands::AddNOC::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.NOCValue = [self asByteSpan:params.nocValue];
+                if (params.icacValue != nil) {
+                    auto & definedValue_0 = request.ICACValue.Emplace();
+                    definedValue_0 = [self asByteSpan:params.icacValue];
+                }
+                request.IPKValue = [self asByteSpan:params.ipkValue];
+                request.caseAdminSubject = params.caseAdminSubject.unsignedLongLongValue;
+                request.adminVendorId = static_cast<std::remove_reference_t<decltype(request.adminVendorId)>>(
+                    params.adminVendorId.unsignedShortValue);
+
+                auto successFn = Callback<OperationalCredentialsClusterNOCResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)updateNOCWithParams:(MTROperationalCredentialsClusterUpdateNOCParams *)params
@@ -7166,30 +8376,46 @@ - (void)updateNOCWithParams:(MTROperationalCredentialsClusterUpdateNOCParams *)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            OperationalCredentials::Commands::UpdateNOC::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.NOCValue = [self asByteSpan:params.nocValue];
-            if (params.icacValue != nil) {
-                auto & definedValue_0 = request.ICACValue.Emplace();
-                definedValue_0 = [self asByteSpan:params.icacValue];
-            }
-
-            auto successFn = Callback<OperationalCredentialsClusterNOCResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                OperationalCredentials::Commands::UpdateNOC::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.NOCValue = [self asByteSpan:params.nocValue];
+                if (params.icacValue != nil) {
+                    auto & definedValue_0 = request.ICACValue.Emplace();
+                    definedValue_0 = [self asByteSpan:params.icacValue];
+                }
+
+                auto successFn = Callback<OperationalCredentialsClusterNOCResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)updateFabricLabelWithParams:(MTROperationalCredentialsClusterUpdateFabricLabelParams *)params
@@ -7200,26 +8426,42 @@ - (void)updateFabricLabelWithParams:(MTROperationalCredentialsClusterUpdateFabri
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            OperationalCredentials::Commands::UpdateFabricLabel::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                OperationalCredentials::Commands::UpdateFabricLabel::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.label = [self asCharSpan:params.label];
-
-            auto successFn = Callback<OperationalCredentialsClusterNOCResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.label = [self asCharSpan:params.label];
+
+                auto successFn = Callback<OperationalCredentialsClusterNOCResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)removeFabricWithParams:(MTROperationalCredentialsClusterRemoveFabricParams *)params
@@ -7230,26 +8472,42 @@ - (void)removeFabricWithParams:(MTROperationalCredentialsClusterRemoveFabricPara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            OperationalCredentials::Commands::RemoveFabric::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                OperationalCredentials::Commands::RemoveFabric::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.fabricIndex = params.fabricIndex.unsignedCharValue;
-
-            auto successFn = Callback<OperationalCredentialsClusterNOCResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.fabricIndex = params.fabricIndex.unsignedCharValue;
+
+                auto successFn = Callback<OperationalCredentialsClusterNOCResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)addTrustedRootCertificateWithParams:(MTROperationalCredentialsClusterAddTrustedRootCertificateParams *)params
@@ -7259,30 +8517,47 @@ - (void)addTrustedRootCertificateWithParams:(MTROperationalCredentialsClusterAdd
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            OperationalCredentials::Commands::AddTrustedRootCertificate::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.rootCertificate = [self asByteSpan:params.rootCertificate];
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                OperationalCredentials::Commands::AddTrustedRootCertificate::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.rootCertificate = [self asByteSpan:params.rootCertificate];
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeNOCsWithParams:(MTRReadParams * _Nullable)params
@@ -7397,69 +8672,86 @@ - (void)keySetWriteWithParams:(MTRGroupKeyManagementClusterKeySetWriteParams *)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            GroupKeyManagement::Commands::KeySetWrite::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.groupKeySet.groupKeySetID = params.groupKeySet.groupKeySetID.unsignedShortValue;
-            request.groupKeySet.groupKeySecurityPolicy
-                = static_cast<std::remove_reference_t<decltype(request.groupKeySet.groupKeySecurityPolicy)>>(
-                    params.groupKeySet.groupKeySecurityPolicy.unsignedCharValue);
-            if (params.groupKeySet.epochKey0 == nil) {
-                request.groupKeySet.epochKey0.SetNull();
-            } else {
-                auto & nonNullValue_1 = request.groupKeySet.epochKey0.SetNonNull();
-                nonNullValue_1 = [self asByteSpan:params.groupKeySet.epochKey0];
-            }
-            if (params.groupKeySet.epochStartTime0 == nil) {
-                request.groupKeySet.epochStartTime0.SetNull();
-            } else {
-                auto & nonNullValue_1 = request.groupKeySet.epochStartTime0.SetNonNull();
-                nonNullValue_1 = params.groupKeySet.epochStartTime0.unsignedLongLongValue;
-            }
-            if (params.groupKeySet.epochKey1 == nil) {
-                request.groupKeySet.epochKey1.SetNull();
-            } else {
-                auto & nonNullValue_1 = request.groupKeySet.epochKey1.SetNonNull();
-                nonNullValue_1 = [self asByteSpan:params.groupKeySet.epochKey1];
-            }
-            if (params.groupKeySet.epochStartTime1 == nil) {
-                request.groupKeySet.epochStartTime1.SetNull();
-            } else {
-                auto & nonNullValue_1 = request.groupKeySet.epochStartTime1.SetNonNull();
-                nonNullValue_1 = params.groupKeySet.epochStartTime1.unsignedLongLongValue;
-            }
-            if (params.groupKeySet.epochKey2 == nil) {
-                request.groupKeySet.epochKey2.SetNull();
-            } else {
-                auto & nonNullValue_1 = request.groupKeySet.epochKey2.SetNonNull();
-                nonNullValue_1 = [self asByteSpan:params.groupKeySet.epochKey2];
-            }
-            if (params.groupKeySet.epochStartTime2 == nil) {
-                request.groupKeySet.epochStartTime2.SetNull();
-            } else {
-                auto & nonNullValue_1 = request.groupKeySet.epochStartTime2.SetNonNull();
-                nonNullValue_1 = params.groupKeySet.epochStartTime2.unsignedLongLongValue;
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                GroupKeyManagement::Commands::KeySetWrite::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.groupKeySet.groupKeySetID = params.groupKeySet.groupKeySetID.unsignedShortValue;
+                request.groupKeySet.groupKeySecurityPolicy
+                    = static_cast<std::remove_reference_t<decltype(request.groupKeySet.groupKeySecurityPolicy)>>(
+                        params.groupKeySet.groupKeySecurityPolicy.unsignedCharValue);
+                if (params.groupKeySet.epochKey0 == nil) {
+                    request.groupKeySet.epochKey0.SetNull();
+                } else {
+                    auto & nonNullValue_1 = request.groupKeySet.epochKey0.SetNonNull();
+                    nonNullValue_1 = [self asByteSpan:params.groupKeySet.epochKey0];
+                }
+                if (params.groupKeySet.epochStartTime0 == nil) {
+                    request.groupKeySet.epochStartTime0.SetNull();
+                } else {
+                    auto & nonNullValue_1 = request.groupKeySet.epochStartTime0.SetNonNull();
+                    nonNullValue_1 = params.groupKeySet.epochStartTime0.unsignedLongLongValue;
+                }
+                if (params.groupKeySet.epochKey1 == nil) {
+                    request.groupKeySet.epochKey1.SetNull();
+                } else {
+                    auto & nonNullValue_1 = request.groupKeySet.epochKey1.SetNonNull();
+                    nonNullValue_1 = [self asByteSpan:params.groupKeySet.epochKey1];
+                }
+                if (params.groupKeySet.epochStartTime1 == nil) {
+                    request.groupKeySet.epochStartTime1.SetNull();
+                } else {
+                    auto & nonNullValue_1 = request.groupKeySet.epochStartTime1.SetNonNull();
+                    nonNullValue_1 = params.groupKeySet.epochStartTime1.unsignedLongLongValue;
+                }
+                if (params.groupKeySet.epochKey2 == nil) {
+                    request.groupKeySet.epochKey2.SetNull();
+                } else {
+                    auto & nonNullValue_1 = request.groupKeySet.epochKey2.SetNonNull();
+                    nonNullValue_1 = [self asByteSpan:params.groupKeySet.epochKey2];
+                }
+                if (params.groupKeySet.epochStartTime2 == nil) {
+                    request.groupKeySet.epochStartTime2.SetNull();
+                } else {
+                    auto & nonNullValue_1 = request.groupKeySet.epochStartTime2.SetNonNull();
+                    nonNullValue_1 = params.groupKeySet.epochStartTime2.unsignedLongLongValue;
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)keySetReadWithParams:(MTRGroupKeyManagementClusterKeySetReadParams *)params
@@ -7470,26 +8762,42 @@ - (void)keySetReadWithParams:(MTRGroupKeyManagementClusterKeySetReadParams *)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRGroupKeyManagementClusterKeySetReadResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            GroupKeyManagement::Commands::KeySetRead::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRGroupKeyManagementClusterKeySetReadResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                GroupKeyManagement::Commands::KeySetRead::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.groupKeySetID = params.groupKeySetID.unsignedShortValue;
-
-            auto successFn = Callback<GroupKeyManagementClusterKeySetReadResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.groupKeySetID = params.groupKeySetID.unsignedShortValue;
+
+                auto successFn = Callback<GroupKeyManagementClusterKeySetReadResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)keySetRemoveWithParams:(MTRGroupKeyManagementClusterKeySetRemoveParams *)params
@@ -7499,30 +8807,47 @@ - (void)keySetRemoveWithParams:(MTRGroupKeyManagementClusterKeySetRemoveParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            GroupKeyManagement::Commands::KeySetRemove::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.groupKeySetID = params.groupKeySetID.unsignedShortValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                GroupKeyManagement::Commands::KeySetRemove::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.groupKeySetID = params.groupKeySetID.unsignedShortValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)keySetReadAllIndicesWithParams:(MTRGroupKeyManagementClusterKeySetReadAllIndicesParams *)params
@@ -7533,47 +8858,65 @@ - (void)keySetReadAllIndicesWithParams:(MTRGroupKeyManagementClusterKeySetReadAl
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            GroupKeyManagement::Commands::KeySetReadAllIndices::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            {
-                using ListType_0 = std::remove_reference_t<decltype(request.groupKeySetIDs)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (params.groupKeySetIDs.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.groupKeySetIDs.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < params.groupKeySetIDs.count; ++i_0) {
-                        if (![params.groupKeySetIDs[i_0] isKindOfClass:[NSNumber class]]) {
-                            // Wrong kind of value.
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackBridge(self.callbackQueue, baseDevice,
+            completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                GroupKeyManagement::Commands::KeySetReadAllIndices::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                {
+                    using ListType_0 = std::remove_reference_t<decltype(request.groupKeySetIDs)>;
+                    using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+                    if (params.groupKeySetIDs.count != 0) {
+                        auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.groupKeySetIDs.count);
+                        if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                             return CHIP_ERROR_INVALID_ARGUMENT;
                         }
-                        auto element_0 = (NSNumber *) params.groupKeySetIDs[i_0];
-                        listHolder_0->mList[i_0] = element_0.unsignedShortValue;
+                        listFreer.add(listHolder_0);
+                        for (size_t i_0 = 0; i_0 < params.groupKeySetIDs.count; ++i_0) {
+                            if (![params.groupKeySetIDs[i_0] isKindOfClass:[NSNumber class]]) {
+                                // Wrong kind of value.
+                                return CHIP_ERROR_INVALID_ARGUMENT;
+                            }
+                            auto element_0 = (NSNumber *) params.groupKeySetIDs[i_0];
+                            listHolder_0->mList[i_0] = element_0.unsignedShortValue;
+                        }
+                        request.groupKeySetIDs = ListType_0(listHolder_0->mList, params.groupKeySetIDs.count);
+                    } else {
+                        request.groupKeySetIDs = ListType_0();
                     }
-                    request.groupKeySetIDs = ListType_0(listHolder_0->mList, params.groupKeySetIDs.count);
-                } else {
-                    request.groupKeySetIDs = ListType_0();
                 }
-            }
 
-            auto successFn = Callback<GroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn
+                    = Callback<GroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeGroupKeyMapWithParams:(MTRReadParams * _Nullable)params
@@ -7905,30 +9248,47 @@ - (void)changeToModeWithParams:(MTRModeSelectClusterChangeToModeParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ModeSelect::Commands::ChangeToMode::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.newMode = params.newMode.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ModeSelect::Commands::ChangeToMode::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.newMode = params.newMode.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeDescriptionWithParams:(MTRReadParams * _Nullable)params
@@ -8081,38 +9441,55 @@ - (void)lockDoorWithParams:(MTRDoorLockClusterLockDoorParams * _Nullable)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            DoorLock::Commands::LockDoor::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            if (!timedInvokeTimeoutMs.HasValue()) {
-                timedInvokeTimeoutMs.SetValue(10000);
-            }
-            if (params != nil) {
-                if (params.pinCode != nil) {
-                    auto & definedValue_0 = request.pinCode.Emplace();
-                    definedValue_0 = [self asByteSpan:params.pinCode];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                DoorLock::Commands::LockDoor::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                if (!timedInvokeTimeoutMs.HasValue()) {
+                    timedInvokeTimeoutMs.SetValue(10000);
+                }
+                if (params != nil) {
+                    if (params.pinCode != nil) {
+                        auto & definedValue_0 = request.pinCode.Emplace();
+                        definedValue_0 = [self asByteSpan:params.pinCode];
+                    }
                 }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
 
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)unlockDoorWithParams:(MTRDoorLockClusterUnlockDoorParams * _Nullable)params
@@ -8122,38 +9499,55 @@ - (void)unlockDoorWithParams:(MTRDoorLockClusterUnlockDoorParams * _Nullable)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            DoorLock::Commands::UnlockDoor::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            if (!timedInvokeTimeoutMs.HasValue()) {
-                timedInvokeTimeoutMs.SetValue(10000);
-            }
-            if (params != nil) {
-                if (params.pinCode != nil) {
-                    auto & definedValue_0 = request.pinCode.Emplace();
-                    definedValue_0 = [self asByteSpan:params.pinCode];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                DoorLock::Commands::UnlockDoor::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                if (!timedInvokeTimeoutMs.HasValue()) {
+                    timedInvokeTimeoutMs.SetValue(10000);
+                }
+                if (params != nil) {
+                    if (params.pinCode != nil) {
+                        auto & definedValue_0 = request.pinCode.Emplace();
+                        definedValue_0 = [self asByteSpan:params.pinCode];
+                    }
                 }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
 
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)unlockWithTimeoutWithParams:(MTRDoorLockClusterUnlockWithTimeoutParams *)params
@@ -8163,37 +9557,54 @@ - (void)unlockWithTimeoutWithParams:(MTRDoorLockClusterUnlockWithTimeoutParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            DoorLock::Commands::UnlockWithTimeout::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            if (!timedInvokeTimeoutMs.HasValue()) {
-                timedInvokeTimeoutMs.SetValue(10000);
-            }
-            request.timeout = params.timeout.unsignedShortValue;
-            if (params.pinCode != nil) {
-                auto & definedValue_0 = request.pinCode.Emplace();
-                definedValue_0 = [self asByteSpan:params.pinCode];
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                DoorLock::Commands::UnlockWithTimeout::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                if (!timedInvokeTimeoutMs.HasValue()) {
+                    timedInvokeTimeoutMs.SetValue(10000);
+                }
+                request.timeout = params.timeout.unsignedShortValue;
+                if (params.pinCode != nil) {
+                    auto & definedValue_0 = request.pinCode.Emplace();
+                    definedValue_0 = [self asByteSpan:params.pinCode];
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)setWeekDayScheduleWithParams:(MTRDoorLockClusterSetWeekDayScheduleParams *)params
@@ -8203,36 +9614,54 @@ - (void)setWeekDayScheduleWithParams:(MTRDoorLockClusterSetWeekDayScheduleParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            DoorLock::Commands::SetWeekDaySchedule::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.weekDayIndex = params.weekDayIndex.unsignedCharValue;
-            request.userIndex = params.userIndex.unsignedShortValue;
-            request.daysMask = static_cast<std::remove_reference_t<decltype(request.daysMask)>>(params.daysMask.unsignedCharValue);
-            request.startHour = params.startHour.unsignedCharValue;
-            request.startMinute = params.startMinute.unsignedCharValue;
-            request.endHour = params.endHour.unsignedCharValue;
-            request.endMinute = params.endMinute.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                DoorLock::Commands::SetWeekDaySchedule::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.weekDayIndex = params.weekDayIndex.unsignedCharValue;
+                request.userIndex = params.userIndex.unsignedShortValue;
+                request.daysMask
+                    = static_cast<std::remove_reference_t<decltype(request.daysMask)>>(params.daysMask.unsignedCharValue);
+                request.startHour = params.startHour.unsignedCharValue;
+                request.startMinute = params.startMinute.unsignedCharValue;
+                request.endHour = params.endHour.unsignedCharValue;
+                request.endMinute = params.endMinute.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)getWeekDayScheduleWithParams:(MTRDoorLockClusterGetWeekDayScheduleParams *)params
@@ -8243,27 +9672,43 @@ - (void)getWeekDayScheduleWithParams:(MTRDoorLockClusterGetWeekDayScheduleParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRDoorLockClusterGetWeekDayScheduleResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            DoorLock::Commands::GetWeekDaySchedule::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRDoorLockClusterGetWeekDayScheduleResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                DoorLock::Commands::GetWeekDaySchedule::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.weekDayIndex = params.weekDayIndex.unsignedCharValue;
-            request.userIndex = params.userIndex.unsignedShortValue;
-
-            auto successFn = Callback<DoorLockClusterGetWeekDayScheduleResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.weekDayIndex = params.weekDayIndex.unsignedCharValue;
+                request.userIndex = params.userIndex.unsignedShortValue;
+
+                auto successFn = Callback<DoorLockClusterGetWeekDayScheduleResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)clearWeekDayScheduleWithParams:(MTRDoorLockClusterClearWeekDayScheduleParams *)params
@@ -8273,31 +9718,48 @@ - (void)clearWeekDayScheduleWithParams:(MTRDoorLockClusterClearWeekDaySchedulePa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            DoorLock::Commands::ClearWeekDaySchedule::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.weekDayIndex = params.weekDayIndex.unsignedCharValue;
-            request.userIndex = params.userIndex.unsignedShortValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                DoorLock::Commands::ClearWeekDaySchedule::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.weekDayIndex = params.weekDayIndex.unsignedCharValue;
+                request.userIndex = params.userIndex.unsignedShortValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)setYearDayScheduleWithParams:(MTRDoorLockClusterSetYearDayScheduleParams *)params
@@ -8307,33 +9769,50 @@ - (void)setYearDayScheduleWithParams:(MTRDoorLockClusterSetYearDayScheduleParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            DoorLock::Commands::SetYearDaySchedule::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.yearDayIndex = params.yearDayIndex.unsignedCharValue;
-            request.userIndex = params.userIndex.unsignedShortValue;
-            request.localStartTime = params.localStartTime.unsignedIntValue;
-            request.localEndTime = params.localEndTime.unsignedIntValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                DoorLock::Commands::SetYearDaySchedule::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.yearDayIndex = params.yearDayIndex.unsignedCharValue;
+                request.userIndex = params.userIndex.unsignedShortValue;
+                request.localStartTime = params.localStartTime.unsignedIntValue;
+                request.localEndTime = params.localEndTime.unsignedIntValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)getYearDayScheduleWithParams:(MTRDoorLockClusterGetYearDayScheduleParams *)params
@@ -8344,27 +9823,43 @@ - (void)getYearDayScheduleWithParams:(MTRDoorLockClusterGetYearDayScheduleParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRDoorLockClusterGetYearDayScheduleResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            DoorLock::Commands::GetYearDaySchedule::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRDoorLockClusterGetYearDayScheduleResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                DoorLock::Commands::GetYearDaySchedule::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.yearDayIndex = params.yearDayIndex.unsignedCharValue;
-            request.userIndex = params.userIndex.unsignedShortValue;
-
-            auto successFn = Callback<DoorLockClusterGetYearDayScheduleResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.yearDayIndex = params.yearDayIndex.unsignedCharValue;
+                request.userIndex = params.userIndex.unsignedShortValue;
+
+                auto successFn = Callback<DoorLockClusterGetYearDayScheduleResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)clearYearDayScheduleWithParams:(MTRDoorLockClusterClearYearDayScheduleParams *)params
@@ -8374,31 +9869,48 @@ - (void)clearYearDayScheduleWithParams:(MTRDoorLockClusterClearYearDaySchedulePa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            DoorLock::Commands::ClearYearDaySchedule::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.yearDayIndex = params.yearDayIndex.unsignedCharValue;
-            request.userIndex = params.userIndex.unsignedShortValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                DoorLock::Commands::ClearYearDaySchedule::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.yearDayIndex = params.yearDayIndex.unsignedCharValue;
+                request.userIndex = params.userIndex.unsignedShortValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)setHolidayScheduleWithParams:(MTRDoorLockClusterSetHolidayScheduleParams *)params
@@ -8408,34 +9920,51 @@ - (void)setHolidayScheduleWithParams:(MTRDoorLockClusterSetHolidayScheduleParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            DoorLock::Commands::SetHolidaySchedule::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.holidayIndex = params.holidayIndex.unsignedCharValue;
-            request.localStartTime = params.localStartTime.unsignedIntValue;
-            request.localEndTime = params.localEndTime.unsignedIntValue;
-            request.operatingMode
-                = static_cast<std::remove_reference_t<decltype(request.operatingMode)>>(params.operatingMode.unsignedCharValue);
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                DoorLock::Commands::SetHolidaySchedule::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.holidayIndex = params.holidayIndex.unsignedCharValue;
+                request.localStartTime = params.localStartTime.unsignedIntValue;
+                request.localEndTime = params.localEndTime.unsignedIntValue;
+                request.operatingMode
+                    = static_cast<std::remove_reference_t<decltype(request.operatingMode)>>(params.operatingMode.unsignedCharValue);
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)getHolidayScheduleWithParams:(MTRDoorLockClusterGetHolidayScheduleParams *)params
@@ -8446,26 +9975,42 @@ - (void)getHolidayScheduleWithParams:(MTRDoorLockClusterGetHolidayScheduleParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRDoorLockClusterGetHolidayScheduleResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            DoorLock::Commands::GetHolidaySchedule::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRDoorLockClusterGetHolidayScheduleResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                DoorLock::Commands::GetHolidaySchedule::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.holidayIndex = params.holidayIndex.unsignedCharValue;
-
-            auto successFn = Callback<DoorLockClusterGetHolidayScheduleResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.holidayIndex = params.holidayIndex.unsignedCharValue;
+
+                auto successFn = Callback<DoorLockClusterGetHolidayScheduleResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)clearHolidayScheduleWithParams:(MTRDoorLockClusterClearHolidayScheduleParams *)params
@@ -8475,30 +10020,47 @@ - (void)clearHolidayScheduleWithParams:(MTRDoorLockClusterClearHolidaySchedulePa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            DoorLock::Commands::ClearHolidaySchedule::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.holidayIndex = params.holidayIndex.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                DoorLock::Commands::ClearHolidaySchedule::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.holidayIndex = params.holidayIndex.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)setUserWithParams:(MTRDoorLockClusterSetUserParams *)params
@@ -8508,67 +10070,85 @@ - (void)setUserWithParams:(MTRDoorLockClusterSetUserParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            DoorLock::Commands::SetUser::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            if (!timedInvokeTimeoutMs.HasValue()) {
-                timedInvokeTimeoutMs.SetValue(10000);
-            }
-            request.operationType
-                = static_cast<std::remove_reference_t<decltype(request.operationType)>>(params.operationType.unsignedCharValue);
-            request.userIndex = params.userIndex.unsignedShortValue;
-            if (params.userName == nil) {
-                request.userName.SetNull();
-            } else {
-                auto & nonNullValue_0 = request.userName.SetNonNull();
-                nonNullValue_0 = [self asCharSpan:params.userName];
-            }
-            if (params.userUniqueId == nil) {
-                request.userUniqueId.SetNull();
-            } else {
-                auto & nonNullValue_0 = request.userUniqueId.SetNonNull();
-                nonNullValue_0 = params.userUniqueId.unsignedIntValue;
-            }
-            if (params.userStatus == nil) {
-                request.userStatus.SetNull();
-            } else {
-                auto & nonNullValue_0 = request.userStatus.SetNonNull();
-                nonNullValue_0
-                    = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(params.userStatus.unsignedCharValue);
-            }
-            if (params.userType == nil) {
-                request.userType.SetNull();
-            } else {
-                auto & nonNullValue_0 = request.userType.SetNonNull();
-                nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(params.userType.unsignedCharValue);
-            }
-            if (params.credentialRule == nil) {
-                request.credentialRule.SetNull();
-            } else {
-                auto & nonNullValue_0 = request.credentialRule.SetNonNull();
-                nonNullValue_0
-                    = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(params.credentialRule.unsignedCharValue);
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                DoorLock::Commands::SetUser::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                if (!timedInvokeTimeoutMs.HasValue()) {
+                    timedInvokeTimeoutMs.SetValue(10000);
+                }
+                request.operationType
+                    = static_cast<std::remove_reference_t<decltype(request.operationType)>>(params.operationType.unsignedCharValue);
+                request.userIndex = params.userIndex.unsignedShortValue;
+                if (params.userName == nil) {
+                    request.userName.SetNull();
+                } else {
+                    auto & nonNullValue_0 = request.userName.SetNonNull();
+                    nonNullValue_0 = [self asCharSpan:params.userName];
+                }
+                if (params.userUniqueId == nil) {
+                    request.userUniqueId.SetNull();
+                } else {
+                    auto & nonNullValue_0 = request.userUniqueId.SetNonNull();
+                    nonNullValue_0 = params.userUniqueId.unsignedIntValue;
+                }
+                if (params.userStatus == nil) {
+                    request.userStatus.SetNull();
+                } else {
+                    auto & nonNullValue_0 = request.userStatus.SetNonNull();
+                    nonNullValue_0
+                        = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(params.userStatus.unsignedCharValue);
+                }
+                if (params.userType == nil) {
+                    request.userType.SetNull();
+                } else {
+                    auto & nonNullValue_0 = request.userType.SetNonNull();
+                    nonNullValue_0
+                        = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(params.userType.unsignedCharValue);
+                }
+                if (params.credentialRule == nil) {
+                    request.credentialRule.SetNull();
+                } else {
+                    auto & nonNullValue_0 = request.credentialRule.SetNonNull();
+                    nonNullValue_0
+                        = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(params.credentialRule.unsignedCharValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)getUserWithParams:(MTRDoorLockClusterGetUserParams *)params
@@ -8579,26 +10159,42 @@ - (void)getUserWithParams:(MTRDoorLockClusterGetUserParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRDoorLockClusterGetUserResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            DoorLock::Commands::GetUser::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRDoorLockClusterGetUserResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                DoorLock::Commands::GetUser::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.userIndex = params.userIndex.unsignedShortValue;
-
-            auto successFn = Callback<DoorLockClusterGetUserResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.userIndex = params.userIndex.unsignedShortValue;
+
+                auto successFn = Callback<DoorLockClusterGetUserResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)clearUserWithParams:(MTRDoorLockClusterClearUserParams *)params
@@ -8608,33 +10204,50 @@ - (void)clearUserWithParams:(MTRDoorLockClusterClearUserParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            DoorLock::Commands::ClearUser::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            if (!timedInvokeTimeoutMs.HasValue()) {
-                timedInvokeTimeoutMs.SetValue(10000);
-            }
-            request.userIndex = params.userIndex.unsignedShortValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                DoorLock::Commands::ClearUser::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                if (!timedInvokeTimeoutMs.HasValue()) {
+                    timedInvokeTimeoutMs.SetValue(10000);
+                }
+                request.userIndex = params.userIndex.unsignedShortValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)setCredentialWithParams:(MTRDoorLockClusterSetCredentialParams *)params
@@ -8645,53 +10258,71 @@ - (void)setCredentialWithParams:(MTRDoorLockClusterSetCredentialParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRDoorLockClusterSetCredentialResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            DoorLock::Commands::SetCredential::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            if (!timedInvokeTimeoutMs.HasValue()) {
-                timedInvokeTimeoutMs.SetValue(10000);
-            }
-            request.operationType
-                = static_cast<std::remove_reference_t<decltype(request.operationType)>>(params.operationType.unsignedCharValue);
-            request.credential.credentialType = static_cast<std::remove_reference_t<decltype(request.credential.credentialType)>>(
-                params.credential.credentialType.unsignedCharValue);
-            request.credential.credentialIndex = params.credential.credentialIndex.unsignedShortValue;
-            request.credentialData = [self asByteSpan:params.credentialData];
-            if (params.userIndex == nil) {
-                request.userIndex.SetNull();
-            } else {
-                auto & nonNullValue_0 = request.userIndex.SetNonNull();
-                nonNullValue_0 = params.userIndex.unsignedShortValue;
-            }
-            if (params.userStatus == nil) {
-                request.userStatus.SetNull();
-            } else {
-                auto & nonNullValue_0 = request.userStatus.SetNonNull();
-                nonNullValue_0
-                    = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(params.userStatus.unsignedCharValue);
-            }
-            if (params.userType == nil) {
-                request.userType.SetNull();
-            } else {
-                auto & nonNullValue_0 = request.userType.SetNonNull();
-                nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(params.userType.unsignedCharValue);
-            }
-
-            auto successFn = Callback<DoorLockClusterSetCredentialResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRDoorLockClusterSetCredentialResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                DoorLock::Commands::SetCredential::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                if (!timedInvokeTimeoutMs.HasValue()) {
+                    timedInvokeTimeoutMs.SetValue(10000);
+                }
+                request.operationType
+                    = static_cast<std::remove_reference_t<decltype(request.operationType)>>(params.operationType.unsignedCharValue);
+                request.credential.credentialType
+                    = static_cast<std::remove_reference_t<decltype(request.credential.credentialType)>>(
+                        params.credential.credentialType.unsignedCharValue);
+                request.credential.credentialIndex = params.credential.credentialIndex.unsignedShortValue;
+                request.credentialData = [self asByteSpan:params.credentialData];
+                if (params.userIndex == nil) {
+                    request.userIndex.SetNull();
+                } else {
+                    auto & nonNullValue_0 = request.userIndex.SetNonNull();
+                    nonNullValue_0 = params.userIndex.unsignedShortValue;
+                }
+                if (params.userStatus == nil) {
+                    request.userStatus.SetNull();
+                } else {
+                    auto & nonNullValue_0 = request.userStatus.SetNonNull();
+                    nonNullValue_0
+                        = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(params.userStatus.unsignedCharValue);
+                }
+                if (params.userType == nil) {
+                    request.userType.SetNull();
+                } else {
+                    auto & nonNullValue_0 = request.userType.SetNonNull();
+                    nonNullValue_0
+                        = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(params.userType.unsignedCharValue);
+                }
+
+                auto successFn = Callback<DoorLockClusterSetCredentialResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)getCredentialStatusWithParams:(MTRDoorLockClusterGetCredentialStatusParams *)params
@@ -8702,28 +10333,45 @@ - (void)getCredentialStatusWithParams:(MTRDoorLockClusterGetCredentialStatusPara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRDoorLockClusterGetCredentialStatusResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            DoorLock::Commands::GetCredentialStatus::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.credential.credentialType = static_cast<std::remove_reference_t<decltype(request.credential.credentialType)>>(
-                params.credential.credentialType.unsignedCharValue);
-            request.credential.credentialIndex = params.credential.credentialIndex.unsignedShortValue;
-
-            auto successFn = Callback<DoorLockClusterGetCredentialStatusResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRDoorLockClusterGetCredentialStatusResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                DoorLock::Commands::GetCredentialStatus::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.credential.credentialType
+                    = static_cast<std::remove_reference_t<decltype(request.credential.credentialType)>>(
+                        params.credential.credentialType.unsignedCharValue);
+                request.credential.credentialIndex = params.credential.credentialIndex.unsignedShortValue;
+
+                auto successFn = Callback<DoorLockClusterGetCredentialStatusResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)clearCredentialWithParams:(MTRDoorLockClusterClearCredentialParams *)params
@@ -8733,40 +10381,57 @@ - (void)clearCredentialWithParams:(MTRDoorLockClusterClearCredentialParams *)par
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            DoorLock::Commands::ClearCredential::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            if (!timedInvokeTimeoutMs.HasValue()) {
-                timedInvokeTimeoutMs.SetValue(10000);
-            }
-            if (params.credential == nil) {
-                request.credential.SetNull();
-            } else {
-                auto & nonNullValue_0 = request.credential.SetNonNull();
-                nonNullValue_0.credentialType = static_cast<std::remove_reference_t<decltype(nonNullValue_0.credentialType)>>(
-                    params.credential.credentialType.unsignedCharValue);
-                nonNullValue_0.credentialIndex = params.credential.credentialIndex.unsignedShortValue;
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                DoorLock::Commands::ClearCredential::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                if (!timedInvokeTimeoutMs.HasValue()) {
+                    timedInvokeTimeoutMs.SetValue(10000);
+                }
+                if (params.credential == nil) {
+                    request.credential.SetNull();
+                } else {
+                    auto & nonNullValue_0 = request.credential.SetNonNull();
+                    nonNullValue_0.credentialType = static_cast<std::remove_reference_t<decltype(nonNullValue_0.credentialType)>>(
+                        params.credential.credentialType.unsignedCharValue);
+                    nonNullValue_0.credentialIndex = params.credential.credentialIndex.unsignedShortValue;
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeLockStateWithParams:(MTRReadParams * _Nullable)params
@@ -9486,29 +11151,46 @@ - (void)upOrOpenWithParams:(MTRWindowCoveringClusterUpOrOpenParams * _Nullable)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            WindowCovering::Commands::UpOrOpen::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                WindowCovering::Commands::UpOrOpen::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)downOrCloseWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -9527,29 +11209,46 @@ - (void)downOrCloseWithParams:(MTRWindowCoveringClusterDownOrCloseParams * _Null
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            WindowCovering::Commands::DownOrClose::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                WindowCovering::Commands::DownOrClose::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)stopMotionWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -9568,29 +11267,46 @@ - (void)stopMotionWithParams:(MTRWindowCoveringClusterStopMotionParams * _Nullab
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            WindowCovering::Commands::StopMotion::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                WindowCovering::Commands::StopMotion::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)goToLiftValueWithParams:(MTRWindowCoveringClusterGoToLiftValueParams *)params
@@ -9600,30 +11316,47 @@ - (void)goToLiftValueWithParams:(MTRWindowCoveringClusterGoToLiftValueParams *)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            WindowCovering::Commands::GoToLiftValue::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.liftValue = params.liftValue.unsignedShortValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                WindowCovering::Commands::GoToLiftValue::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.liftValue = params.liftValue.unsignedShortValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)goToLiftPercentageWithParams:(MTRWindowCoveringClusterGoToLiftPercentageParams *)params
@@ -9633,30 +11366,47 @@ - (void)goToLiftPercentageWithParams:(MTRWindowCoveringClusterGoToLiftPercentage
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            WindowCovering::Commands::GoToLiftPercentage::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.liftPercent100thsValue = params.liftPercent100thsValue.unsignedShortValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                WindowCovering::Commands::GoToLiftPercentage::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.liftPercent100thsValue = params.liftPercent100thsValue.unsignedShortValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)goToTiltValueWithParams:(MTRWindowCoveringClusterGoToTiltValueParams *)params
@@ -9666,30 +11416,47 @@ - (void)goToTiltValueWithParams:(MTRWindowCoveringClusterGoToTiltValueParams *)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            WindowCovering::Commands::GoToTiltValue::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.tiltValue = params.tiltValue.unsignedShortValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                WindowCovering::Commands::GoToTiltValue::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.tiltValue = params.tiltValue.unsignedShortValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)goToTiltPercentageWithParams:(MTRWindowCoveringClusterGoToTiltPercentageParams *)params
@@ -9699,30 +11466,47 @@ - (void)goToTiltPercentageWithParams:(MTRWindowCoveringClusterGoToTiltPercentage
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            WindowCovering::Commands::GoToTiltPercentage::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.tiltPercent100thsValue = params.tiltPercent100thsValue.unsignedShortValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                WindowCovering::Commands::GoToTiltPercentage::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.tiltPercent100thsValue = params.tiltPercent100thsValue.unsignedShortValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeTypeWithParams:(MTRReadParams * _Nullable)params
@@ -9984,30 +11768,47 @@ - (void)barrierControlGoToPercentWithParams:(MTRBarrierControlClusterBarrierCont
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            BarrierControl::Commands::BarrierControlGoToPercent::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.percentOpen = params.percentOpen.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                BarrierControl::Commands::BarrierControlGoToPercent::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.percentOpen = params.percentOpen.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)barrierControlStopWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -10026,29 +11827,46 @@ - (void)barrierControlStopWithParams:(MTRBarrierControlClusterBarrierControlStop
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            BarrierControl::Commands::BarrierControlStop::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                BarrierControl::Commands::BarrierControlStop::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeBarrierMovingStateWithParams:(MTRReadParams * _Nullable)params
@@ -10632,31 +12450,48 @@ - (void)setpointRaiseLowerWithParams:(MTRThermostatClusterSetpointRaiseLowerPara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Thermostat::Commands::SetpointRaiseLower::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.mode = static_cast<std::remove_reference_t<decltype(request.mode)>>(params.mode.unsignedCharValue);
-            request.amount = params.amount.charValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Thermostat::Commands::SetpointRaiseLower::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.mode = static_cast<std::remove_reference_t<decltype(request.mode)>>(params.mode.unsignedCharValue);
+                request.amount = params.amount.charValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)setWeeklyScheduleWithParams:(MTRThermostatClusterSetWeeklyScheduleParams *)params
@@ -10666,68 +12501,85 @@ - (void)setWeeklyScheduleWithParams:(MTRThermostatClusterSetWeeklyScheduleParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Thermostat::Commands::SetWeeklySchedule::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.numberOfTransitionsForSequence = params.numberOfTransitionsForSequence.unsignedCharValue;
-            request.dayOfWeekForSequence = static_cast<std::remove_reference_t<decltype(request.dayOfWeekForSequence)>>(
-                params.dayOfWeekForSequence.unsignedCharValue);
-            request.modeForSequence
-                = static_cast<std::remove_reference_t<decltype(request.modeForSequence)>>(params.modeForSequence.unsignedCharValue);
-            {
-                using ListType_0 = std::remove_reference_t<decltype(request.transitions)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (params.transitions.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.transitions.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < params.transitions.count; ++i_0) {
-                        if (![params.transitions[i_0] isKindOfClass:[MTRThermostatClusterThermostatScheduleTransition class]]) {
-                            // Wrong kind of value.
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Thermostat::Commands::SetWeeklySchedule::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.numberOfTransitionsForSequence = params.numberOfTransitionsForSequence.unsignedCharValue;
+                request.dayOfWeekForSequence = static_cast<std::remove_reference_t<decltype(request.dayOfWeekForSequence)>>(
+                    params.dayOfWeekForSequence.unsignedCharValue);
+                request.modeForSequence = static_cast<std::remove_reference_t<decltype(request.modeForSequence)>>(
+                    params.modeForSequence.unsignedCharValue);
+                {
+                    using ListType_0 = std::remove_reference_t<decltype(request.transitions)>;
+                    using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+                    if (params.transitions.count != 0) {
+                        auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.transitions.count);
+                        if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                             return CHIP_ERROR_INVALID_ARGUMENT;
                         }
-                        auto element_0 = (MTRThermostatClusterThermostatScheduleTransition *) params.transitions[i_0];
-                        listHolder_0->mList[i_0].transitionTime = element_0.transitionTime.unsignedShortValue;
-                        if (element_0.heatSetpoint == nil) {
-                            listHolder_0->mList[i_0].heatSetpoint.SetNull();
-                        } else {
-                            auto & nonNullValue_2 = listHolder_0->mList[i_0].heatSetpoint.SetNonNull();
-                            nonNullValue_2 = element_0.heatSetpoint.shortValue;
-                        }
-                        if (element_0.coolSetpoint == nil) {
-                            listHolder_0->mList[i_0].coolSetpoint.SetNull();
-                        } else {
-                            auto & nonNullValue_2 = listHolder_0->mList[i_0].coolSetpoint.SetNonNull();
-                            nonNullValue_2 = element_0.coolSetpoint.shortValue;
+                        listFreer.add(listHolder_0);
+                        for (size_t i_0 = 0; i_0 < params.transitions.count; ++i_0) {
+                            if (![params.transitions[i_0] isKindOfClass:[MTRThermostatClusterThermostatScheduleTransition class]]) {
+                                // Wrong kind of value.
+                                return CHIP_ERROR_INVALID_ARGUMENT;
+                            }
+                            auto element_0 = (MTRThermostatClusterThermostatScheduleTransition *) params.transitions[i_0];
+                            listHolder_0->mList[i_0].transitionTime = element_0.transitionTime.unsignedShortValue;
+                            if (element_0.heatSetpoint == nil) {
+                                listHolder_0->mList[i_0].heatSetpoint.SetNull();
+                            } else {
+                                auto & nonNullValue_2 = listHolder_0->mList[i_0].heatSetpoint.SetNonNull();
+                                nonNullValue_2 = element_0.heatSetpoint.shortValue;
+                            }
+                            if (element_0.coolSetpoint == nil) {
+                                listHolder_0->mList[i_0].coolSetpoint.SetNull();
+                            } else {
+                                auto & nonNullValue_2 = listHolder_0->mList[i_0].coolSetpoint.SetNonNull();
+                                nonNullValue_2 = element_0.coolSetpoint.shortValue;
+                            }
                         }
+                        request.transitions = ListType_0(listHolder_0->mList, params.transitions.count);
+                    } else {
+                        request.transitions = ListType_0();
                     }
-                    request.transitions = ListType_0(listHolder_0->mList, params.transitions.count);
-                } else {
-                    request.transitions = ListType_0();
                 }
-            }
 
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)getWeeklyScheduleWithParams:(MTRThermostatClusterGetWeeklyScheduleParams *)params
@@ -10738,29 +12590,45 @@ - (void)getWeeklyScheduleWithParams:(MTRThermostatClusterGetWeeklyScheduleParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRThermostatClusterGetWeeklyScheduleResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Thermostat::Commands::GetWeeklySchedule::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.daysToReturn
-                = static_cast<std::remove_reference_t<decltype(request.daysToReturn)>>(params.daysToReturn.unsignedCharValue);
-            request.modeToReturn
-                = static_cast<std::remove_reference_t<decltype(request.modeToReturn)>>(params.modeToReturn.unsignedCharValue);
-
-            auto successFn = Callback<ThermostatClusterGetWeeklyScheduleResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRThermostatClusterGetWeeklyScheduleResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Thermostat::Commands::GetWeeklySchedule::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.daysToReturn
+                    = static_cast<std::remove_reference_t<decltype(request.daysToReturn)>>(params.daysToReturn.unsignedCharValue);
+                request.modeToReturn
+                    = static_cast<std::remove_reference_t<decltype(request.modeToReturn)>>(params.modeToReturn.unsignedCharValue);
+
+                auto successFn = Callback<ThermostatClusterGetWeeklyScheduleResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)clearWeeklyScheduleWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -10779,29 +12647,46 @@ - (void)clearWeeklyScheduleWithParams:(MTRThermostatClusterClearWeeklySchedulePa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Thermostat::Commands::ClearWeeklySchedule::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Thermostat::Commands::ClearWeeklySchedule::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeLocalTemperatureWithParams:(MTRReadParams * _Nullable)params
@@ -12197,35 +14082,52 @@ - (void)moveToHueWithParams:(MTRColorControlClusterMoveToHueParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ColorControl::Commands::MoveToHue::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.hue = params.hue.unsignedCharValue;
-            request.direction
-                = static_cast<std::remove_reference_t<decltype(request.direction)>>(params.direction.unsignedCharValue);
-            request.transitionTime = params.transitionTime.unsignedShortValue;
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ColorControl::Commands::MoveToHue::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.hue = params.hue.unsignedCharValue;
+                request.direction
+                    = static_cast<std::remove_reference_t<decltype(request.direction)>>(params.direction.unsignedCharValue);
+                request.transitionTime = params.transitionTime.unsignedShortValue;
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)moveHueWithParams:(MTRColorControlClusterMoveHueParams *)params
@@ -12235,33 +14137,51 @@ - (void)moveHueWithParams:(MTRColorControlClusterMoveHueParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ColorControl::Commands::MoveHue::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.moveMode = static_cast<std::remove_reference_t<decltype(request.moveMode)>>(params.moveMode.unsignedCharValue);
-            request.rate = params.rate.unsignedCharValue;
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ColorControl::Commands::MoveHue::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.moveMode
+                    = static_cast<std::remove_reference_t<decltype(request.moveMode)>>(params.moveMode.unsignedCharValue);
+                request.rate = params.rate.unsignedCharValue;
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)stepHueWithParams:(MTRColorControlClusterStepHueParams *)params
@@ -12271,34 +14191,52 @@ - (void)stepHueWithParams:(MTRColorControlClusterStepHueParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ColorControl::Commands::StepHue::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.stepMode = static_cast<std::remove_reference_t<decltype(request.stepMode)>>(params.stepMode.unsignedCharValue);
-            request.stepSize = params.stepSize.unsignedCharValue;
-            request.transitionTime = params.transitionTime.unsignedCharValue;
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ColorControl::Commands::StepHue::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.stepMode
+                    = static_cast<std::remove_reference_t<decltype(request.stepMode)>>(params.stepMode.unsignedCharValue);
+                request.stepSize = params.stepSize.unsignedCharValue;
+                request.transitionTime = params.transitionTime.unsignedCharValue;
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)moveToSaturationWithParams:(MTRColorControlClusterMoveToSaturationParams *)params
@@ -12308,33 +14246,50 @@ - (void)moveToSaturationWithParams:(MTRColorControlClusterMoveToSaturationParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ColorControl::Commands::MoveToSaturation::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.saturation = params.saturation.unsignedCharValue;
-            request.transitionTime = params.transitionTime.unsignedShortValue;
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ColorControl::Commands::MoveToSaturation::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.saturation = params.saturation.unsignedCharValue;
+                request.transitionTime = params.transitionTime.unsignedShortValue;
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)moveSaturationWithParams:(MTRColorControlClusterMoveSaturationParams *)params
@@ -12344,33 +14299,51 @@ - (void)moveSaturationWithParams:(MTRColorControlClusterMoveSaturationParams *)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ColorControl::Commands::MoveSaturation::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.moveMode = static_cast<std::remove_reference_t<decltype(request.moveMode)>>(params.moveMode.unsignedCharValue);
-            request.rate = params.rate.unsignedCharValue;
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ColorControl::Commands::MoveSaturation::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.moveMode
+                    = static_cast<std::remove_reference_t<decltype(request.moveMode)>>(params.moveMode.unsignedCharValue);
+                request.rate = params.rate.unsignedCharValue;
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)stepSaturationWithParams:(MTRColorControlClusterStepSaturationParams *)params
@@ -12380,34 +14353,52 @@ - (void)stepSaturationWithParams:(MTRColorControlClusterStepSaturationParams *)p
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ColorControl::Commands::StepSaturation::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.stepMode = static_cast<std::remove_reference_t<decltype(request.stepMode)>>(params.stepMode.unsignedCharValue);
-            request.stepSize = params.stepSize.unsignedCharValue;
-            request.transitionTime = params.transitionTime.unsignedCharValue;
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ColorControl::Commands::StepSaturation::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.stepMode
+                    = static_cast<std::remove_reference_t<decltype(request.stepMode)>>(params.stepMode.unsignedCharValue);
+                request.stepSize = params.stepSize.unsignedCharValue;
+                request.transitionTime = params.transitionTime.unsignedCharValue;
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)moveToHueAndSaturationWithParams:(MTRColorControlClusterMoveToHueAndSaturationParams *)params
@@ -12417,34 +14408,51 @@ - (void)moveToHueAndSaturationWithParams:(MTRColorControlClusterMoveToHueAndSatu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ColorControl::Commands::MoveToHueAndSaturation::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.hue = params.hue.unsignedCharValue;
-            request.saturation = params.saturation.unsignedCharValue;
-            request.transitionTime = params.transitionTime.unsignedShortValue;
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ColorControl::Commands::MoveToHueAndSaturation::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.hue = params.hue.unsignedCharValue;
+                request.saturation = params.saturation.unsignedCharValue;
+                request.transitionTime = params.transitionTime.unsignedShortValue;
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)moveToColorWithParams:(MTRColorControlClusterMoveToColorParams *)params
@@ -12454,34 +14462,51 @@ - (void)moveToColorWithParams:(MTRColorControlClusterMoveToColorParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ColorControl::Commands::MoveToColor::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.colorX = params.colorX.unsignedShortValue;
-            request.colorY = params.colorY.unsignedShortValue;
-            request.transitionTime = params.transitionTime.unsignedShortValue;
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ColorControl::Commands::MoveToColor::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.colorX = params.colorX.unsignedShortValue;
+                request.colorY = params.colorY.unsignedShortValue;
+                request.transitionTime = params.transitionTime.unsignedShortValue;
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)moveColorWithParams:(MTRColorControlClusterMoveColorParams *)params
@@ -12491,33 +14516,50 @@ - (void)moveColorWithParams:(MTRColorControlClusterMoveColorParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ColorControl::Commands::MoveColor::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.rateX = params.rateX.shortValue;
-            request.rateY = params.rateY.shortValue;
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ColorControl::Commands::MoveColor::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.rateX = params.rateX.shortValue;
+                request.rateY = params.rateY.shortValue;
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)stepColorWithParams:(MTRColorControlClusterStepColorParams *)params
@@ -12527,34 +14569,51 @@ - (void)stepColorWithParams:(MTRColorControlClusterStepColorParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ColorControl::Commands::StepColor::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.stepX = params.stepX.shortValue;
-            request.stepY = params.stepY.shortValue;
-            request.transitionTime = params.transitionTime.unsignedShortValue;
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ColorControl::Commands::StepColor::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.stepX = params.stepX.shortValue;
+                request.stepY = params.stepY.shortValue;
+                request.transitionTime = params.transitionTime.unsignedShortValue;
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)moveToColorTemperatureWithParams:(MTRColorControlClusterMoveToColorTemperatureParams *)params
@@ -12564,33 +14623,50 @@ - (void)moveToColorTemperatureWithParams:(MTRColorControlClusterMoveToColorTempe
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ColorControl::Commands::MoveToColorTemperature::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.colorTemperature = params.colorTemperature.unsignedShortValue;
-            request.transitionTime = params.transitionTime.unsignedShortValue;
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ColorControl::Commands::MoveToColorTemperature::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.colorTemperature = params.colorTemperature.unsignedShortValue;
+                request.transitionTime = params.transitionTime.unsignedShortValue;
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)enhancedMoveToHueWithParams:(MTRColorControlClusterEnhancedMoveToHueParams *)params
@@ -12600,35 +14676,52 @@ - (void)enhancedMoveToHueWithParams:(MTRColorControlClusterEnhancedMoveToHuePara
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ColorControl::Commands::EnhancedMoveToHue::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.enhancedHue = params.enhancedHue.unsignedShortValue;
-            request.direction
-                = static_cast<std::remove_reference_t<decltype(request.direction)>>(params.direction.unsignedCharValue);
-            request.transitionTime = params.transitionTime.unsignedShortValue;
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ColorControl::Commands::EnhancedMoveToHue::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.enhancedHue = params.enhancedHue.unsignedShortValue;
+                request.direction
+                    = static_cast<std::remove_reference_t<decltype(request.direction)>>(params.direction.unsignedCharValue);
+                request.transitionTime = params.transitionTime.unsignedShortValue;
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)enhancedMoveHueWithParams:(MTRColorControlClusterEnhancedMoveHueParams *)params
@@ -12638,33 +14731,51 @@ - (void)enhancedMoveHueWithParams:(MTRColorControlClusterEnhancedMoveHueParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ColorControl::Commands::EnhancedMoveHue::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.moveMode = static_cast<std::remove_reference_t<decltype(request.moveMode)>>(params.moveMode.unsignedCharValue);
-            request.rate = params.rate.unsignedShortValue;
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ColorControl::Commands::EnhancedMoveHue::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.moveMode
+                    = static_cast<std::remove_reference_t<decltype(request.moveMode)>>(params.moveMode.unsignedCharValue);
+                request.rate = params.rate.unsignedShortValue;
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)enhancedStepHueWithParams:(MTRColorControlClusterEnhancedStepHueParams *)params
@@ -12674,34 +14785,52 @@ - (void)enhancedStepHueWithParams:(MTRColorControlClusterEnhancedStepHueParams *
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ColorControl::Commands::EnhancedStepHue::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.stepMode = static_cast<std::remove_reference_t<decltype(request.stepMode)>>(params.stepMode.unsignedCharValue);
-            request.stepSize = params.stepSize.unsignedShortValue;
-            request.transitionTime = params.transitionTime.unsignedShortValue;
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ColorControl::Commands::EnhancedStepHue::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.stepMode
+                    = static_cast<std::remove_reference_t<decltype(request.stepMode)>>(params.stepMode.unsignedCharValue);
+                request.stepSize = params.stepSize.unsignedShortValue;
+                request.transitionTime = params.transitionTime.unsignedShortValue;
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)enhancedMoveToHueAndSaturationWithParams:(MTRColorControlClusterEnhancedMoveToHueAndSaturationParams *)params
@@ -12711,34 +14840,51 @@ - (void)enhancedMoveToHueAndSaturationWithParams:(MTRColorControlClusterEnhanced
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ColorControl::Commands::EnhancedMoveToHueAndSaturation::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.enhancedHue = params.enhancedHue.unsignedShortValue;
-            request.saturation = params.saturation.unsignedCharValue;
-            request.transitionTime = params.transitionTime.unsignedShortValue;
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ColorControl::Commands::EnhancedMoveToHueAndSaturation::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.enhancedHue = params.enhancedHue.unsignedShortValue;
+                request.saturation = params.saturation.unsignedCharValue;
+                request.transitionTime = params.transitionTime.unsignedShortValue;
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)colorLoopSetWithParams:(MTRColorControlClusterColorLoopSetParams *)params
@@ -12748,38 +14894,55 @@ - (void)colorLoopSetWithParams:(MTRColorControlClusterColorLoopSetParams *)param
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ColorControl::Commands::ColorLoopSet::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.updateFlags
-                = static_cast<std::remove_reference_t<decltype(request.updateFlags)>>(params.updateFlags.unsignedCharValue);
-            request.action = static_cast<std::remove_reference_t<decltype(request.action)>>(params.action.unsignedCharValue);
-            request.direction
-                = static_cast<std::remove_reference_t<decltype(request.direction)>>(params.direction.unsignedCharValue);
-            request.time = params.time.unsignedShortValue;
-            request.startHue = params.startHue.unsignedShortValue;
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ColorControl::Commands::ColorLoopSet::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.updateFlags
+                    = static_cast<std::remove_reference_t<decltype(request.updateFlags)>>(params.updateFlags.unsignedCharValue);
+                request.action = static_cast<std::remove_reference_t<decltype(request.action)>>(params.action.unsignedCharValue);
+                request.direction
+                    = static_cast<std::remove_reference_t<decltype(request.direction)>>(params.direction.unsignedCharValue);
+                request.time = params.time.unsignedShortValue;
+                request.startHue = params.startHue.unsignedShortValue;
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)stopMoveStepWithParams:(MTRColorControlClusterStopMoveStepParams *)params
@@ -12789,31 +14952,48 @@ - (void)stopMoveStepWithParams:(MTRColorControlClusterStopMoveStepParams *)param
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ColorControl::Commands::StopMoveStep::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ColorControl::Commands::StopMoveStep::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)moveColorTemperatureWithParams:(MTRColorControlClusterMoveColorTemperatureParams *)params
@@ -12823,35 +15003,53 @@ - (void)moveColorTemperatureWithParams:(MTRColorControlClusterMoveColorTemperatu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ColorControl::Commands::MoveColorTemperature::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.moveMode = static_cast<std::remove_reference_t<decltype(request.moveMode)>>(params.moveMode.unsignedCharValue);
-            request.rate = params.rate.unsignedShortValue;
-            request.colorTemperatureMinimumMireds = params.colorTemperatureMinimumMireds.unsignedShortValue;
-            request.colorTemperatureMaximumMireds = params.colorTemperatureMaximumMireds.unsignedShortValue;
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ColorControl::Commands::MoveColorTemperature::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.moveMode
+                    = static_cast<std::remove_reference_t<decltype(request.moveMode)>>(params.moveMode.unsignedCharValue);
+                request.rate = params.rate.unsignedShortValue;
+                request.colorTemperatureMinimumMireds = params.colorTemperatureMinimumMireds.unsignedShortValue;
+                request.colorTemperatureMaximumMireds = params.colorTemperatureMaximumMireds.unsignedShortValue;
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)stepColorTemperatureWithParams:(MTRColorControlClusterStepColorTemperatureParams *)params
@@ -12861,36 +15059,54 @@ - (void)stepColorTemperatureWithParams:(MTRColorControlClusterStepColorTemperatu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ColorControl::Commands::StepColorTemperature::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.stepMode = static_cast<std::remove_reference_t<decltype(request.stepMode)>>(params.stepMode.unsignedCharValue);
-            request.stepSize = params.stepSize.unsignedShortValue;
-            request.transitionTime = params.transitionTime.unsignedShortValue;
-            request.colorTemperatureMinimumMireds = params.colorTemperatureMinimumMireds.unsignedShortValue;
-            request.colorTemperatureMaximumMireds = params.colorTemperatureMaximumMireds.unsignedShortValue;
-            request.optionsMask = params.optionsMask.unsignedCharValue;
-            request.optionsOverride = params.optionsOverride.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ColorControl::Commands::StepColorTemperature::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.stepMode
+                    = static_cast<std::remove_reference_t<decltype(request.stepMode)>>(params.stepMode.unsignedCharValue);
+                request.stepSize = params.stepSize.unsignedShortValue;
+                request.transitionTime = params.transitionTime.unsignedShortValue;
+                request.colorTemperatureMinimumMireds = params.colorTemperatureMinimumMireds.unsignedShortValue;
+                request.colorTemperatureMaximumMireds = params.colorTemperatureMaximumMireds.unsignedShortValue;
+                request.optionsMask = params.optionsMask.unsignedCharValue;
+                request.optionsOverride = params.optionsOverride.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeCurrentHueWithParams:(MTRReadParams * _Nullable)params
@@ -14890,26 +17106,42 @@ - (void)changeChannelWithParams:(MTRChannelClusterChangeChannelParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRChannelClusterChangeChannelResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Channel::Commands::ChangeChannel::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRChannelClusterChangeChannelResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Channel::Commands::ChangeChannel::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.match = [self asCharSpan:params.match];
-
-            auto successFn = Callback<ChannelClusterChangeChannelResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.match = [self asCharSpan:params.match];
+
+                auto successFn = Callback<ChannelClusterChangeChannelResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)changeChannelByNumberWithParams:(MTRChannelClusterChangeChannelByNumberParams *)params
@@ -14919,31 +17151,48 @@ - (void)changeChannelByNumberWithParams:(MTRChannelClusterChangeChannelByNumberP
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Channel::Commands::ChangeChannelByNumber::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.majorNumber = params.majorNumber.unsignedShortValue;
-            request.minorNumber = params.minorNumber.unsignedShortValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Channel::Commands::ChangeChannelByNumber::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.majorNumber = params.majorNumber.unsignedShortValue;
+                request.minorNumber = params.minorNumber.unsignedShortValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)skipChannelWithParams:(MTRChannelClusterSkipChannelParams *)params
@@ -14953,30 +17202,47 @@ - (void)skipChannelWithParams:(MTRChannelClusterSkipChannelParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            Channel::Commands::SkipChannel::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.count = params.count.unsignedShortValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                Channel::Commands::SkipChannel::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.count = params.count.unsignedShortValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeChannelListWithParams:(MTRReadParams * _Nullable)params
@@ -15068,30 +17334,46 @@ - (void)navigateTargetWithParams:(MTRTargetNavigatorClusterNavigateTargetParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRTargetNavigatorClusterNavigateTargetResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TargetNavigator::Commands::NavigateTarget::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.target = params.target.unsignedCharValue;
-            if (params.data != nil) {
-                auto & definedValue_0 = request.data.Emplace();
-                definedValue_0 = [self asCharSpan:params.data];
-            }
-
-            auto successFn = Callback<TargetNavigatorClusterNavigateTargetResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRTargetNavigatorClusterNavigateTargetResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TargetNavigator::Commands::NavigateTarget::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.target = params.target.unsignedCharValue;
+                if (params.data != nil) {
+                    auto & definedValue_0 = request.data.Emplace();
+                    definedValue_0 = [self asCharSpan:params.data];
+                }
+
+                auto successFn = Callback<TargetNavigatorClusterNavigateTargetResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeTargetListWithParams:(MTRReadParams * _Nullable)params
@@ -15185,25 +17467,41 @@ - (void)playWithParams:(MTRMediaPlaybackClusterPlayParams * _Nullable)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            MediaPlayback::Commands::Play::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                MediaPlayback::Commands::Play::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
 
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)pauseWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -15224,25 +17522,41 @@ - (void)pauseWithParams:(MTRMediaPlaybackClusterPauseParams * _Nullable)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            MediaPlayback::Commands::Pause::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                MediaPlayback::Commands::Pause::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
 
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)stopPlaybackWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -15263,25 +17577,41 @@ - (void)stopPlaybackWithParams:(MTRMediaPlaybackClusterStopPlaybackParams * _Nul
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            MediaPlayback::Commands::StopPlayback::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                MediaPlayback::Commands::StopPlayback::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
 
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)startOverWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -15302,25 +17632,41 @@ - (void)startOverWithParams:(MTRMediaPlaybackClusterStartOverParams * _Nullable)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            MediaPlayback::Commands::StartOver::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                MediaPlayback::Commands::StartOver::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
 
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)previousWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -15341,25 +17687,41 @@ - (void)previousWithParams:(MTRMediaPlaybackClusterPreviousParams * _Nullable)pa
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            MediaPlayback::Commands::Previous::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                MediaPlayback::Commands::Previous::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
 
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)nextWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -15380,25 +17742,41 @@ - (void)nextWithParams:(MTRMediaPlaybackClusterNextParams * _Nullable)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            MediaPlayback::Commands::Next::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                MediaPlayback::Commands::Next::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
 
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)rewindWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -15419,25 +17797,41 @@ - (void)rewindWithParams:(MTRMediaPlaybackClusterRewindParams * _Nullable)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            MediaPlayback::Commands::Rewind::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                MediaPlayback::Commands::Rewind::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
 
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)fastForwardWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -15458,25 +17852,41 @@ - (void)fastForwardWithParams:(MTRMediaPlaybackClusterFastForwardParams * _Nulla
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            MediaPlayback::Commands::FastForward::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                MediaPlayback::Commands::FastForward::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
 
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)skipForwardWithParams:(MTRMediaPlaybackClusterSkipForwardParams *)params
@@ -15487,26 +17897,42 @@ - (void)skipForwardWithParams:(MTRMediaPlaybackClusterSkipForwardParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            MediaPlayback::Commands::SkipForward::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                MediaPlayback::Commands::SkipForward::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.deltaPositionMilliseconds = params.deltaPositionMilliseconds.unsignedLongLongValue;
-
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.deltaPositionMilliseconds = params.deltaPositionMilliseconds.unsignedLongLongValue;
+
+                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)skipBackwardWithParams:(MTRMediaPlaybackClusterSkipBackwardParams *)params
@@ -15517,26 +17943,42 @@ - (void)skipBackwardWithParams:(MTRMediaPlaybackClusterSkipBackwardParams *)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            MediaPlayback::Commands::SkipBackward::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                MediaPlayback::Commands::SkipBackward::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.deltaPositionMilliseconds = params.deltaPositionMilliseconds.unsignedLongLongValue;
-
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.deltaPositionMilliseconds = params.deltaPositionMilliseconds.unsignedLongLongValue;
+
+                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)seekWithParams:(MTRMediaPlaybackClusterSeekParams *)params
@@ -15547,26 +17989,42 @@ - (void)seekWithParams:(MTRMediaPlaybackClusterSeekParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            MediaPlayback::Commands::Seek::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                MediaPlayback::Commands::Seek::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.position = params.position.unsignedLongLongValue;
-
-            auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.position = params.position.unsignedLongLongValue;
+
+                auto successFn = Callback<MediaPlaybackClusterPlaybackResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeCurrentStateWithParams:(MTRReadParams * _Nullable)params
@@ -15689,30 +18147,47 @@ - (void)selectInputWithParams:(MTRMediaInputClusterSelectInputParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            MediaInput::Commands::SelectInput::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.index = params.index.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                MediaInput::Commands::SelectInput::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.index = params.index.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)showInputStatusWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -15731,29 +18206,46 @@ - (void)showInputStatusWithParams:(MTRMediaInputClusterShowInputStatusParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            MediaInput::Commands::ShowInputStatus::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                MediaInput::Commands::ShowInputStatus::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)hideInputStatusWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -15772,29 +18264,46 @@ - (void)hideInputStatusWithParams:(MTRMediaInputClusterHideInputStatusParams * _
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            MediaInput::Commands::HideInputStatus::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                MediaInput::Commands::HideInputStatus::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)renameInputWithParams:(MTRMediaInputClusterRenameInputParams *)params
@@ -15804,31 +18313,48 @@ - (void)renameInputWithParams:(MTRMediaInputClusterRenameInputParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            MediaInput::Commands::RenameInput::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.index = params.index.unsignedCharValue;
-            request.name = [self asCharSpan:params.name];
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                MediaInput::Commands::RenameInput::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.index = params.index.unsignedCharValue;
+                request.name = [self asCharSpan:params.name];
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeInputListWithParams:(MTRReadParams * _Nullable)params
@@ -15920,29 +18446,46 @@ - (void)sleepWithParams:(MTRLowPowerClusterSleepParams * _Nullable)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            LowPower::Commands::Sleep::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                LowPower::Commands::Sleep::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
@@ -16010,26 +18553,42 @@ - (void)sendKeyWithParams:(MTRKeypadInputClusterSendKeyParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRKeypadInputClusterSendKeyResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            KeypadInput::Commands::SendKey::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRKeypadInputClusterSendKeyResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                KeypadInput::Commands::SendKey::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.keyCode = static_cast<std::remove_reference_t<decltype(request.keyCode)>>(params.keyCode.unsignedCharValue);
-
-            auto successFn = Callback<KeypadInputClusterSendKeyResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.keyCode = static_cast<std::remove_reference_t<decltype(request.keyCode)>>(params.keyCode.unsignedCharValue);
+
+                auto successFn = Callback<KeypadInputClusterSendKeyResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
@@ -16097,82 +18656,99 @@ - (void)launchContentWithParams:(MTRContentLauncherClusterLaunchContentParams *)
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRContentLauncherClusterLaunchResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ContentLauncher::Commands::LaunchContent::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            {
-                using ListType_1 = std::remove_reference_t<decltype(request.search.parameterList)>;
-                using ListMemberType_1 = ListMemberTypeGetter<ListType_1>::Type;
-                if (params.search.parameterList.count != 0) {
-                    auto * listHolder_1 = new ListHolder<ListMemberType_1>(params.search.parameterList.count);
-                    if (listHolder_1 == nullptr || listHolder_1->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_1);
-                    for (size_t i_1 = 0; i_1 < params.search.parameterList.count; ++i_1) {
-                        if (![params.search.parameterList[i_1] isKindOfClass:[MTRContentLauncherClusterParameter class]]) {
-                            // Wrong kind of value.
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRContentLauncherClusterLaunchResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ContentLauncher::Commands::LaunchContent::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                {
+                    using ListType_1 = std::remove_reference_t<decltype(request.search.parameterList)>;
+                    using ListMemberType_1 = ListMemberTypeGetter<ListType_1>::Type;
+                    if (params.search.parameterList.count != 0) {
+                        auto * listHolder_1 = new ListHolder<ListMemberType_1>(params.search.parameterList.count);
+                        if (listHolder_1 == nullptr || listHolder_1->mList == nullptr) {
                             return CHIP_ERROR_INVALID_ARGUMENT;
                         }
-                        auto element_1 = (MTRContentLauncherClusterParameter *) params.search.parameterList[i_1];
-                        listHolder_1->mList[i_1].type
-                            = static_cast<std::remove_reference_t<decltype(listHolder_1->mList[i_1].type)>>(
-                                element_1.type.unsignedCharValue);
-                        listHolder_1->mList[i_1].value = [self asCharSpan:element_1.value];
-                        if (element_1.externalIDList != nil) {
-                            auto & definedValue_3 = listHolder_1->mList[i_1].externalIDList.Emplace();
-                            {
-                                using ListType_4 = std::remove_reference_t<decltype(definedValue_3)>;
-                                using ListMemberType_4 = ListMemberTypeGetter<ListType_4>::Type;
-                                if (element_1.externalIDList.count != 0) {
-                                    auto * listHolder_4 = new ListHolder<ListMemberType_4>(element_1.externalIDList.count);
-                                    if (listHolder_4 == nullptr || listHolder_4->mList == nullptr) {
-                                        return CHIP_ERROR_INVALID_ARGUMENT;
-                                    }
-                                    listFreer.add(listHolder_4);
-                                    for (size_t i_4 = 0; i_4 < element_1.externalIDList.count; ++i_4) {
-                                        if (![element_1.externalIDList[i_4]
-                                                isKindOfClass:[MTRContentLauncherClusterAdditionalInfo class]]) {
-                                            // Wrong kind of value.
+                        listFreer.add(listHolder_1);
+                        for (size_t i_1 = 0; i_1 < params.search.parameterList.count; ++i_1) {
+                            if (![params.search.parameterList[i_1] isKindOfClass:[MTRContentLauncherClusterParameter class]]) {
+                                // Wrong kind of value.
+                                return CHIP_ERROR_INVALID_ARGUMENT;
+                            }
+                            auto element_1 = (MTRContentLauncherClusterParameter *) params.search.parameterList[i_1];
+                            listHolder_1->mList[i_1].type
+                                = static_cast<std::remove_reference_t<decltype(listHolder_1->mList[i_1].type)>>(
+                                    element_1.type.unsignedCharValue);
+                            listHolder_1->mList[i_1].value = [self asCharSpan:element_1.value];
+                            if (element_1.externalIDList != nil) {
+                                auto & definedValue_3 = listHolder_1->mList[i_1].externalIDList.Emplace();
+                                {
+                                    using ListType_4 = std::remove_reference_t<decltype(definedValue_3)>;
+                                    using ListMemberType_4 = ListMemberTypeGetter<ListType_4>::Type;
+                                    if (element_1.externalIDList.count != 0) {
+                                        auto * listHolder_4 = new ListHolder<ListMemberType_4>(element_1.externalIDList.count);
+                                        if (listHolder_4 == nullptr || listHolder_4->mList == nullptr) {
                                             return CHIP_ERROR_INVALID_ARGUMENT;
                                         }
-                                        auto element_4 = (MTRContentLauncherClusterAdditionalInfo *) element_1.externalIDList[i_4];
-                                        listHolder_4->mList[i_4].name = [self asCharSpan:element_4.name];
-                                        listHolder_4->mList[i_4].value = [self asCharSpan:element_4.value];
+                                        listFreer.add(listHolder_4);
+                                        for (size_t i_4 = 0; i_4 < element_1.externalIDList.count; ++i_4) {
+                                            if (![element_1.externalIDList[i_4]
+                                                    isKindOfClass:[MTRContentLauncherClusterAdditionalInfo class]]) {
+                                                // Wrong kind of value.
+                                                return CHIP_ERROR_INVALID_ARGUMENT;
+                                            }
+                                            auto element_4
+                                                = (MTRContentLauncherClusterAdditionalInfo *) element_1.externalIDList[i_4];
+                                            listHolder_4->mList[i_4].name = [self asCharSpan:element_4.name];
+                                            listHolder_4->mList[i_4].value = [self asCharSpan:element_4.value];
+                                        }
+                                        definedValue_3 = ListType_4(listHolder_4->mList, element_1.externalIDList.count);
+                                    } else {
+                                        definedValue_3 = ListType_4();
                                     }
-                                    definedValue_3 = ListType_4(listHolder_4->mList, element_1.externalIDList.count);
-                                } else {
-                                    definedValue_3 = ListType_4();
                                 }
                             }
                         }
+                        request.search.parameterList = ListType_1(listHolder_1->mList, params.search.parameterList.count);
+                    } else {
+                        request.search.parameterList = ListType_1();
                     }
-                    request.search.parameterList = ListType_1(listHolder_1->mList, params.search.parameterList.count);
-                } else {
-                    request.search.parameterList = ListType_1();
                 }
-            }
-            request.autoPlay = params.autoPlay.boolValue;
-            if (params.data != nil) {
-                auto & definedValue_0 = request.data.Emplace();
-                definedValue_0 = [self asCharSpan:params.data];
-            }
-
-            auto successFn = Callback<ContentLauncherClusterLaunchResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
+                request.autoPlay = params.autoPlay.boolValue;
+                if (params.data != nil) {
+                    auto & definedValue_0 = request.data.Emplace();
+                    definedValue_0 = [self asCharSpan:params.data];
+                }
 
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<ContentLauncherClusterLaunchResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)launchURLWithParams:(MTRContentLauncherClusterLaunchURLParams *)params
@@ -16183,124 +18759,140 @@ - (void)launchURLWithParams:(MTRContentLauncherClusterLaunchURLParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRContentLauncherClusterLaunchResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ContentLauncher::Commands::LaunchURL::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.contentURL = [self asCharSpan:params.contentURL];
-            if (params.displayString != nil) {
-                auto & definedValue_0 = request.displayString.Emplace();
-                definedValue_0 = [self asCharSpan:params.displayString];
-            }
-            if (params.brandingInformation != nil) {
-                auto & definedValue_0 = request.brandingInformation.Emplace();
-                definedValue_0.providerName = [self asCharSpan:params.brandingInformation.providerName];
-                if (params.brandingInformation.background != nil) {
-                    auto & definedValue_2 = definedValue_0.background.Emplace();
-                    if (params.brandingInformation.background.imageUrl != nil) {
-                        auto & definedValue_4 = definedValue_2.imageUrl.Emplace();
-                        definedValue_4 = [self asCharSpan:params.brandingInformation.background.imageUrl];
-                    }
-                    if (params.brandingInformation.background.color != nil) {
-                        auto & definedValue_4 = definedValue_2.color.Emplace();
-                        definedValue_4 = [self asCharSpan:params.brandingInformation.background.color];
-                    }
-                    if (params.brandingInformation.background.size != nil) {
-                        auto & definedValue_4 = definedValue_2.size.Emplace();
-                        definedValue_4.width = params.brandingInformation.background.size.width.doubleValue;
-                        definedValue_4.height = params.brandingInformation.background.size.height.doubleValue;
-                        definedValue_4.metric = static_cast<std::remove_reference_t<decltype(definedValue_4.metric)>>(
-                            params.brandingInformation.background.size.metric.unsignedCharValue);
-                    }
-                }
-                if (params.brandingInformation.logo != nil) {
-                    auto & definedValue_2 = definedValue_0.logo.Emplace();
-                    if (params.brandingInformation.logo.imageUrl != nil) {
-                        auto & definedValue_4 = definedValue_2.imageUrl.Emplace();
-                        definedValue_4 = [self asCharSpan:params.brandingInformation.logo.imageUrl];
-                    }
-                    if (params.brandingInformation.logo.color != nil) {
-                        auto & definedValue_4 = definedValue_2.color.Emplace();
-                        definedValue_4 = [self asCharSpan:params.brandingInformation.logo.color];
-                    }
-                    if (params.brandingInformation.logo.size != nil) {
-                        auto & definedValue_4 = definedValue_2.size.Emplace();
-                        definedValue_4.width = params.brandingInformation.logo.size.width.doubleValue;
-                        definedValue_4.height = params.brandingInformation.logo.size.height.doubleValue;
-                        definedValue_4.metric = static_cast<std::remove_reference_t<decltype(definedValue_4.metric)>>(
-                            params.brandingInformation.logo.size.metric.unsignedCharValue);
-                    }
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRContentLauncherClusterLaunchResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ContentLauncher::Commands::LaunchURL::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-                if (params.brandingInformation.progressBar != nil) {
-                    auto & definedValue_2 = definedValue_0.progressBar.Emplace();
-                    if (params.brandingInformation.progressBar.imageUrl != nil) {
-                        auto & definedValue_4 = definedValue_2.imageUrl.Emplace();
-                        definedValue_4 = [self asCharSpan:params.brandingInformation.progressBar.imageUrl];
-                    }
-                    if (params.brandingInformation.progressBar.color != nil) {
-                        auto & definedValue_4 = definedValue_2.color.Emplace();
-                        definedValue_4 = [self asCharSpan:params.brandingInformation.progressBar.color];
-                    }
-                    if (params.brandingInformation.progressBar.size != nil) {
-                        auto & definedValue_4 = definedValue_2.size.Emplace();
-                        definedValue_4.width = params.brandingInformation.progressBar.size.width.doubleValue;
-                        definedValue_4.height = params.brandingInformation.progressBar.size.height.doubleValue;
-                        definedValue_4.metric = static_cast<std::remove_reference_t<decltype(definedValue_4.metric)>>(
-                            params.brandingInformation.progressBar.size.metric.unsignedCharValue);
-                    }
+                request.contentURL = [self asCharSpan:params.contentURL];
+                if (params.displayString != nil) {
+                    auto & definedValue_0 = request.displayString.Emplace();
+                    definedValue_0 = [self asCharSpan:params.displayString];
                 }
-                if (params.brandingInformation.splash != nil) {
-                    auto & definedValue_2 = definedValue_0.splash.Emplace();
-                    if (params.brandingInformation.splash.imageUrl != nil) {
-                        auto & definedValue_4 = definedValue_2.imageUrl.Emplace();
-                        definedValue_4 = [self asCharSpan:params.brandingInformation.splash.imageUrl];
-                    }
-                    if (params.brandingInformation.splash.color != nil) {
-                        auto & definedValue_4 = definedValue_2.color.Emplace();
-                        definedValue_4 = [self asCharSpan:params.brandingInformation.splash.color];
+                if (params.brandingInformation != nil) {
+                    auto & definedValue_0 = request.brandingInformation.Emplace();
+                    definedValue_0.providerName = [self asCharSpan:params.brandingInformation.providerName];
+                    if (params.brandingInformation.background != nil) {
+                        auto & definedValue_2 = definedValue_0.background.Emplace();
+                        if (params.brandingInformation.background.imageUrl != nil) {
+                            auto & definedValue_4 = definedValue_2.imageUrl.Emplace();
+                            definedValue_4 = [self asCharSpan:params.brandingInformation.background.imageUrl];
+                        }
+                        if (params.brandingInformation.background.color != nil) {
+                            auto & definedValue_4 = definedValue_2.color.Emplace();
+                            definedValue_4 = [self asCharSpan:params.brandingInformation.background.color];
+                        }
+                        if (params.brandingInformation.background.size != nil) {
+                            auto & definedValue_4 = definedValue_2.size.Emplace();
+                            definedValue_4.width = params.brandingInformation.background.size.width.doubleValue;
+                            definedValue_4.height = params.brandingInformation.background.size.height.doubleValue;
+                            definedValue_4.metric = static_cast<std::remove_reference_t<decltype(definedValue_4.metric)>>(
+                                params.brandingInformation.background.size.metric.unsignedCharValue);
+                        }
                     }
-                    if (params.brandingInformation.splash.size != nil) {
-                        auto & definedValue_4 = definedValue_2.size.Emplace();
-                        definedValue_4.width = params.brandingInformation.splash.size.width.doubleValue;
-                        definedValue_4.height = params.brandingInformation.splash.size.height.doubleValue;
-                        definedValue_4.metric = static_cast<std::remove_reference_t<decltype(definedValue_4.metric)>>(
-                            params.brandingInformation.splash.size.metric.unsignedCharValue);
+                    if (params.brandingInformation.logo != nil) {
+                        auto & definedValue_2 = definedValue_0.logo.Emplace();
+                        if (params.brandingInformation.logo.imageUrl != nil) {
+                            auto & definedValue_4 = definedValue_2.imageUrl.Emplace();
+                            definedValue_4 = [self asCharSpan:params.brandingInformation.logo.imageUrl];
+                        }
+                        if (params.brandingInformation.logo.color != nil) {
+                            auto & definedValue_4 = definedValue_2.color.Emplace();
+                            definedValue_4 = [self asCharSpan:params.brandingInformation.logo.color];
+                        }
+                        if (params.brandingInformation.logo.size != nil) {
+                            auto & definedValue_4 = definedValue_2.size.Emplace();
+                            definedValue_4.width = params.brandingInformation.logo.size.width.doubleValue;
+                            definedValue_4.height = params.brandingInformation.logo.size.height.doubleValue;
+                            definedValue_4.metric = static_cast<std::remove_reference_t<decltype(definedValue_4.metric)>>(
+                                params.brandingInformation.logo.size.metric.unsignedCharValue);
+                        }
                     }
-                }
-                if (params.brandingInformation.waterMark != nil) {
-                    auto & definedValue_2 = definedValue_0.waterMark.Emplace();
-                    if (params.brandingInformation.waterMark.imageUrl != nil) {
-                        auto & definedValue_4 = definedValue_2.imageUrl.Emplace();
-                        definedValue_4 = [self asCharSpan:params.brandingInformation.waterMark.imageUrl];
+                    if (params.brandingInformation.progressBar != nil) {
+                        auto & definedValue_2 = definedValue_0.progressBar.Emplace();
+                        if (params.brandingInformation.progressBar.imageUrl != nil) {
+                            auto & definedValue_4 = definedValue_2.imageUrl.Emplace();
+                            definedValue_4 = [self asCharSpan:params.brandingInformation.progressBar.imageUrl];
+                        }
+                        if (params.brandingInformation.progressBar.color != nil) {
+                            auto & definedValue_4 = definedValue_2.color.Emplace();
+                            definedValue_4 = [self asCharSpan:params.brandingInformation.progressBar.color];
+                        }
+                        if (params.brandingInformation.progressBar.size != nil) {
+                            auto & definedValue_4 = definedValue_2.size.Emplace();
+                            definedValue_4.width = params.brandingInformation.progressBar.size.width.doubleValue;
+                            definedValue_4.height = params.brandingInformation.progressBar.size.height.doubleValue;
+                            definedValue_4.metric = static_cast<std::remove_reference_t<decltype(definedValue_4.metric)>>(
+                                params.brandingInformation.progressBar.size.metric.unsignedCharValue);
+                        }
                     }
-                    if (params.brandingInformation.waterMark.color != nil) {
-                        auto & definedValue_4 = definedValue_2.color.Emplace();
-                        definedValue_4 = [self asCharSpan:params.brandingInformation.waterMark.color];
+                    if (params.brandingInformation.splash != nil) {
+                        auto & definedValue_2 = definedValue_0.splash.Emplace();
+                        if (params.brandingInformation.splash.imageUrl != nil) {
+                            auto & definedValue_4 = definedValue_2.imageUrl.Emplace();
+                            definedValue_4 = [self asCharSpan:params.brandingInformation.splash.imageUrl];
+                        }
+                        if (params.brandingInformation.splash.color != nil) {
+                            auto & definedValue_4 = definedValue_2.color.Emplace();
+                            definedValue_4 = [self asCharSpan:params.brandingInformation.splash.color];
+                        }
+                        if (params.brandingInformation.splash.size != nil) {
+                            auto & definedValue_4 = definedValue_2.size.Emplace();
+                            definedValue_4.width = params.brandingInformation.splash.size.width.doubleValue;
+                            definedValue_4.height = params.brandingInformation.splash.size.height.doubleValue;
+                            definedValue_4.metric = static_cast<std::remove_reference_t<decltype(definedValue_4.metric)>>(
+                                params.brandingInformation.splash.size.metric.unsignedCharValue);
+                        }
                     }
-                    if (params.brandingInformation.waterMark.size != nil) {
-                        auto & definedValue_4 = definedValue_2.size.Emplace();
-                        definedValue_4.width = params.brandingInformation.waterMark.size.width.doubleValue;
-                        definedValue_4.height = params.brandingInformation.waterMark.size.height.doubleValue;
-                        definedValue_4.metric = static_cast<std::remove_reference_t<decltype(definedValue_4.metric)>>(
-                            params.brandingInformation.waterMark.size.metric.unsignedCharValue);
+                    if (params.brandingInformation.waterMark != nil) {
+                        auto & definedValue_2 = definedValue_0.waterMark.Emplace();
+                        if (params.brandingInformation.waterMark.imageUrl != nil) {
+                            auto & definedValue_4 = definedValue_2.imageUrl.Emplace();
+                            definedValue_4 = [self asCharSpan:params.brandingInformation.waterMark.imageUrl];
+                        }
+                        if (params.brandingInformation.waterMark.color != nil) {
+                            auto & definedValue_4 = definedValue_2.color.Emplace();
+                            definedValue_4 = [self asCharSpan:params.brandingInformation.waterMark.color];
+                        }
+                        if (params.brandingInformation.waterMark.size != nil) {
+                            auto & definedValue_4 = definedValue_2.size.Emplace();
+                            definedValue_4.width = params.brandingInformation.waterMark.size.width.doubleValue;
+                            definedValue_4.height = params.brandingInformation.waterMark.size.height.doubleValue;
+                            definedValue_4.metric = static_cast<std::remove_reference_t<decltype(definedValue_4.metric)>>(
+                                params.brandingInformation.waterMark.size.metric.unsignedCharValue);
+                        }
                     }
                 }
-            }
 
-            auto successFn = Callback<ContentLauncherClusterLaunchResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<ContentLauncherClusterLaunchResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeAcceptHeaderWithParams:(MTRReadParams * _Nullable)params
@@ -16404,30 +18996,47 @@ - (void)selectOutputWithParams:(MTRAudioOutputClusterSelectOutputParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            AudioOutput::Commands::SelectOutput::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.index = params.index.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                AudioOutput::Commands::SelectOutput::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.index = params.index.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)renameOutputWithParams:(MTRAudioOutputClusterRenameOutputParams *)params
@@ -16437,31 +19046,48 @@ - (void)renameOutputWithParams:(MTRAudioOutputClusterRenameOutputParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            AudioOutput::Commands::RenameOutput::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.index = params.index.unsignedCharValue;
-            request.name = [self asCharSpan:params.name];
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                AudioOutput::Commands::RenameOutput::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.index = params.index.unsignedCharValue;
+                request.name = [self asCharSpan:params.name];
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeOutputListWithParams:(MTRReadParams * _Nullable)params
@@ -16545,31 +19171,47 @@ - (void)launchAppWithParams:(MTRApplicationLauncherClusterLaunchAppParams *)para
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ApplicationLauncher::Commands::LaunchApp::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.application.catalogVendorId = params.application.catalogVendorId.unsignedShortValue;
-            request.application.applicationId = [self asCharSpan:params.application.applicationId];
-            if (params.data != nil) {
-                auto & definedValue_0 = request.data.Emplace();
-                definedValue_0 = [self asByteSpan:params.data];
-            }
-
-            auto successFn = Callback<ApplicationLauncherClusterLauncherResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ApplicationLauncher::Commands::LaunchApp::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.application.catalogVendorId = params.application.catalogVendorId.unsignedShortValue;
+                request.application.applicationId = [self asCharSpan:params.application.applicationId];
+                if (params.data != nil) {
+                    auto & definedValue_0 = request.data.Emplace();
+                    definedValue_0 = [self asByteSpan:params.data];
+                }
+
+                auto successFn = Callback<ApplicationLauncherClusterLauncherResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)stopAppWithParams:(MTRApplicationLauncherClusterStopAppParams *)params
@@ -16580,27 +19222,43 @@ - (void)stopAppWithParams:(MTRApplicationLauncherClusterStopAppParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ApplicationLauncher::Commands::StopApp::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ApplicationLauncher::Commands::StopApp::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.application.catalogVendorId = params.application.catalogVendorId.unsignedShortValue;
-            request.application.applicationId = [self asCharSpan:params.application.applicationId];
-
-            auto successFn = Callback<ApplicationLauncherClusterLauncherResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.application.catalogVendorId = params.application.catalogVendorId.unsignedShortValue;
+                request.application.applicationId = [self asCharSpan:params.application.applicationId];
+
+                auto successFn = Callback<ApplicationLauncherClusterLauncherResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)hideAppWithParams:(MTRApplicationLauncherClusterHideAppParams *)params
@@ -16611,27 +19269,43 @@ - (void)hideAppWithParams:(MTRApplicationLauncherClusterHideAppParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ApplicationLauncher::Commands::HideApp::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ApplicationLauncher::Commands::HideApp::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.application.catalogVendorId = params.application.catalogVendorId.unsignedShortValue;
-            request.application.applicationId = [self asCharSpan:params.application.applicationId];
-
-            auto successFn = Callback<ApplicationLauncherClusterLauncherResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.application.catalogVendorId = params.application.catalogVendorId.unsignedShortValue;
+                request.application.applicationId = [self asCharSpan:params.application.applicationId];
+
+                auto successFn = Callback<ApplicationLauncherClusterLauncherResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeCatalogListWithParams:(MTRReadParams * _Nullable)params
@@ -16855,29 +19529,45 @@ - (void)getSetupPINWithParams:(MTRAccountLoginClusterGetSetupPINParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRAccountLoginClusterGetSetupPINResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            AccountLogin::Commands::GetSetupPIN::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            if (!timedInvokeTimeoutMs.HasValue()) {
-                timedInvokeTimeoutMs.SetValue(10000);
-            }
-            request.tempAccountIdentifier = [self asCharSpan:params.tempAccountIdentifier];
-
-            auto successFn = Callback<AccountLoginClusterGetSetupPINResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRAccountLoginClusterGetSetupPINResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                AccountLogin::Commands::GetSetupPIN::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                if (!timedInvokeTimeoutMs.HasValue()) {
+                    timedInvokeTimeoutMs.SetValue(10000);
+                }
+                request.tempAccountIdentifier = [self asCharSpan:params.tempAccountIdentifier];
+
+                auto successFn = Callback<AccountLoginClusterGetSetupPINResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)loginWithParams:(MTRAccountLoginClusterLoginParams *)params
@@ -16887,34 +19577,51 @@ - (void)loginWithParams:(MTRAccountLoginClusterLoginParams *)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            AccountLogin::Commands::Login::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            if (!timedInvokeTimeoutMs.HasValue()) {
-                timedInvokeTimeoutMs.SetValue(10000);
-            }
-            request.tempAccountIdentifier = [self asCharSpan:params.tempAccountIdentifier];
-            request.setupPIN = [self asCharSpan:params.setupPIN];
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                AccountLogin::Commands::Login::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                if (!timedInvokeTimeoutMs.HasValue()) {
+                    timedInvokeTimeoutMs.SetValue(10000);
+                }
+                request.tempAccountIdentifier = [self asCharSpan:params.tempAccountIdentifier];
+                request.setupPIN = [self asCharSpan:params.setupPIN];
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)logoutWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -16933,32 +19640,49 @@ - (void)logoutWithParams:(MTRAccountLoginClusterLogoutParams * _Nullable)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            AccountLogin::Commands::Logout::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            if (!timedInvokeTimeoutMs.HasValue()) {
-                timedInvokeTimeoutMs.SetValue(10000);
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                AccountLogin::Commands::Logout::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                if (!timedInvokeTimeoutMs.HasValue()) {
+                    timedInvokeTimeoutMs.SetValue(10000);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params
@@ -17034,29 +19758,46 @@ - (void)getProfileInfoCommandWithParams:(MTRElectricalMeasurementClusterGetProfi
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ElectricalMeasurement::Commands::GetProfileInfoCommand::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ElectricalMeasurement::Commands::GetProfileInfoCommand::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)getMeasurementProfileCommandWithParams:(MTRElectricalMeasurementClusterGetMeasurementProfileCommandParams *)params
@@ -17066,32 +19807,49 @@ - (void)getMeasurementProfileCommandWithParams:(MTRElectricalMeasurementClusterG
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            ElectricalMeasurement::Commands::GetMeasurementProfileCommand::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.attributeId = params.attributeId.unsignedShortValue;
-            request.startTime = params.startTime.unsignedIntValue;
-            request.numberOfIntervals = params.numberOfIntervals.unsignedCharValue;
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                ElectricalMeasurement::Commands::GetMeasurementProfileCommand::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.attributeId = params.attributeId.unsignedShortValue;
+                request.startTime = params.startTime.unsignedIntValue;
+                request.numberOfIntervals = params.numberOfIntervals.unsignedCharValue;
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeMeasurementTypeWithParams:(MTRReadParams * _Nullable)params
@@ -18355,29 +21113,46 @@ - (void)testWithParams:(MTRTestClusterClusterTestParams * _Nullable)params
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::Test::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::Test::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)testNotHandledWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -18396,29 +21171,46 @@ - (void)testNotHandledWithParams:(MTRTestClusterClusterTestNotHandledParams * _N
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::TestNotHandled::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::TestNotHandled::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)testSpecificWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -18439,25 +21231,41 @@ - (void)testSpecificWithParams:(MTRTestClusterClusterTestSpecificParams * _Nulla
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRTestClusterClusterTestSpecificResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::TestSpecific::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRTestClusterClusterTestSpecificResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::TestSpecific::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-
-            auto successFn = Callback<TestClusterClusterTestSpecificResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
 
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<TestClusterClusterTestSpecificResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)testUnknownCommandWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -18476,29 +21284,46 @@ - (void)testUnknownCommandWithParams:(MTRTestClusterClusterTestUnknownCommandPar
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::TestUnknownCommand::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::TestUnknownCommand::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)testAddArgumentsWithParams:(MTRTestClusterClusterTestAddArgumentsParams *)params
@@ -18509,27 +21334,43 @@ - (void)testAddArgumentsWithParams:(MTRTestClusterClusterTestAddArgumentsParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRTestClusterClusterTestAddArgumentsResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::TestAddArguments::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRTestClusterClusterTestAddArgumentsResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::TestAddArguments::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.arg1 = params.arg1.unsignedCharValue;
-            request.arg2 = params.arg2.unsignedCharValue;
-
-            auto successFn = Callback<TestClusterClusterTestAddArgumentsResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.arg1 = params.arg1.unsignedCharValue;
+                request.arg2 = params.arg2.unsignedCharValue;
+
+                auto successFn = Callback<TestClusterClusterTestAddArgumentsResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)testSimpleArgumentRequestWithParams:(MTRTestClusterClusterTestSimpleArgumentRequestParams *)params
@@ -18540,26 +21381,42 @@ - (void)testSimpleArgumentRequestWithParams:(MTRTestClusterClusterTestSimpleArgu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRTestClusterClusterTestSimpleArgumentResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::TestSimpleArgumentRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRTestClusterClusterTestSimpleArgumentResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::TestSimpleArgumentRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.arg1 = params.arg1.boolValue;
-
-            auto successFn = Callback<TestClusterClusterTestSimpleArgumentResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.arg1 = params.arg1.boolValue;
+
+                auto successFn = Callback<TestClusterClusterTestSimpleArgumentResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)testStructArrayArgumentRequestWithParams:(MTRTestClusterClusterTestStructArrayArgumentRequestParams *)params
@@ -18571,235 +21428,253 @@ - (void)testStructArrayArgumentRequestWithParams:(MTRTestClusterClusterTestStruc
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRTestClusterClusterTestStructArrayArgumentResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::TestStructArrayArgumentRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            {
-                using ListType_0 = std::remove_reference_t<decltype(request.arg1)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (params.arg1.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.arg1.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < params.arg1.count; ++i_0) {
-                        if (![params.arg1[i_0] isKindOfClass:[MTRTestClusterClusterNestedStructList class]]) {
-                            // Wrong kind of value.
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRTestClusterClusterTestStructArrayArgumentResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::TestStructArrayArgumentRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                {
+                    using ListType_0 = std::remove_reference_t<decltype(request.arg1)>;
+                    using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+                    if (params.arg1.count != 0) {
+                        auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.arg1.count);
+                        if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                             return CHIP_ERROR_INVALID_ARGUMENT;
                         }
-                        auto element_0 = (MTRTestClusterClusterNestedStructList *) params.arg1[i_0];
-                        listHolder_0->mList[i_0].a = element_0.a.unsignedCharValue;
-                        listHolder_0->mList[i_0].b = element_0.b.boolValue;
-                        listHolder_0->mList[i_0].c.a = element_0.c.a.unsignedCharValue;
-                        listHolder_0->mList[i_0].c.b = element_0.c.b.boolValue;
-                        listHolder_0->mList[i_0].c.c = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].c.c)>>(
-                            element_0.c.c.unsignedCharValue);
-                        listHolder_0->mList[i_0].c.d = [self asByteSpan:element_0.c.d];
-                        listHolder_0->mList[i_0].c.e = [self asCharSpan:element_0.c.e];
-                        listHolder_0->mList[i_0].c.f = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].c.f)>>(
-                            element_0.c.f.unsignedCharValue);
-                        listHolder_0->mList[i_0].c.g = element_0.c.g.floatValue;
-                        listHolder_0->mList[i_0].c.h = element_0.c.h.doubleValue;
-                        {
-                            using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].d)>;
-                            using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
-                            if (element_0.d.count != 0) {
-                                auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.d.count);
-                                if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
-                                    return CHIP_ERROR_INVALID_ARGUMENT;
-                                }
-                                listFreer.add(listHolder_2);
-                                for (size_t i_2 = 0; i_2 < element_0.d.count; ++i_2) {
-                                    if (![element_0.d[i_2] isKindOfClass:[MTRTestClusterClusterSimpleStruct class]]) {
-                                        // Wrong kind of value.
+                        listFreer.add(listHolder_0);
+                        for (size_t i_0 = 0; i_0 < params.arg1.count; ++i_0) {
+                            if (![params.arg1[i_0] isKindOfClass:[MTRTestClusterClusterNestedStructList class]]) {
+                                // Wrong kind of value.
+                                return CHIP_ERROR_INVALID_ARGUMENT;
+                            }
+                            auto element_0 = (MTRTestClusterClusterNestedStructList *) params.arg1[i_0];
+                            listHolder_0->mList[i_0].a = element_0.a.unsignedCharValue;
+                            listHolder_0->mList[i_0].b = element_0.b.boolValue;
+                            listHolder_0->mList[i_0].c.a = element_0.c.a.unsignedCharValue;
+                            listHolder_0->mList[i_0].c.b = element_0.c.b.boolValue;
+                            listHolder_0->mList[i_0].c.c
+                                = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].c.c)>>(
+                                    element_0.c.c.unsignedCharValue);
+                            listHolder_0->mList[i_0].c.d = [self asByteSpan:element_0.c.d];
+                            listHolder_0->mList[i_0].c.e = [self asCharSpan:element_0.c.e];
+                            listHolder_0->mList[i_0].c.f
+                                = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].c.f)>>(
+                                    element_0.c.f.unsignedCharValue);
+                            listHolder_0->mList[i_0].c.g = element_0.c.g.floatValue;
+                            listHolder_0->mList[i_0].c.h = element_0.c.h.doubleValue;
+                            {
+                                using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].d)>;
+                                using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
+                                if (element_0.d.count != 0) {
+                                    auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.d.count);
+                                    if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
                                         return CHIP_ERROR_INVALID_ARGUMENT;
                                     }
-                                    auto element_2 = (MTRTestClusterClusterSimpleStruct *) element_0.d[i_2];
-                                    listHolder_2->mList[i_2].a = element_2.a.unsignedCharValue;
-                                    listHolder_2->mList[i_2].b = element_2.b.boolValue;
-                                    listHolder_2->mList[i_2].c
-                                        = static_cast<std::remove_reference_t<decltype(listHolder_2->mList[i_2].c)>>(
-                                            element_2.c.unsignedCharValue);
-                                    listHolder_2->mList[i_2].d = [self asByteSpan:element_2.d];
-                                    listHolder_2->mList[i_2].e = [self asCharSpan:element_2.e];
-                                    listHolder_2->mList[i_2].f
-                                        = static_cast<std::remove_reference_t<decltype(listHolder_2->mList[i_2].f)>>(
-                                            element_2.f.unsignedCharValue);
-                                    listHolder_2->mList[i_2].g = element_2.g.floatValue;
-                                    listHolder_2->mList[i_2].h = element_2.h.doubleValue;
+                                    listFreer.add(listHolder_2);
+                                    for (size_t i_2 = 0; i_2 < element_0.d.count; ++i_2) {
+                                        if (![element_0.d[i_2] isKindOfClass:[MTRTestClusterClusterSimpleStruct class]]) {
+                                            // Wrong kind of value.
+                                            return CHIP_ERROR_INVALID_ARGUMENT;
+                                        }
+                                        auto element_2 = (MTRTestClusterClusterSimpleStruct *) element_0.d[i_2];
+                                        listHolder_2->mList[i_2].a = element_2.a.unsignedCharValue;
+                                        listHolder_2->mList[i_2].b = element_2.b.boolValue;
+                                        listHolder_2->mList[i_2].c
+                                            = static_cast<std::remove_reference_t<decltype(listHolder_2->mList[i_2].c)>>(
+                                                element_2.c.unsignedCharValue);
+                                        listHolder_2->mList[i_2].d = [self asByteSpan:element_2.d];
+                                        listHolder_2->mList[i_2].e = [self asCharSpan:element_2.e];
+                                        listHolder_2->mList[i_2].f
+                                            = static_cast<std::remove_reference_t<decltype(listHolder_2->mList[i_2].f)>>(
+                                                element_2.f.unsignedCharValue);
+                                        listHolder_2->mList[i_2].g = element_2.g.floatValue;
+                                        listHolder_2->mList[i_2].h = element_2.h.doubleValue;
+                                    }
+                                    listHolder_0->mList[i_0].d = ListType_2(listHolder_2->mList, element_0.d.count);
+                                } else {
+                                    listHolder_0->mList[i_0].d = ListType_2();
                                 }
-                                listHolder_0->mList[i_0].d = ListType_2(listHolder_2->mList, element_0.d.count);
-                            } else {
-                                listHolder_0->mList[i_0].d = ListType_2();
                             }
-                        }
-                        {
-                            using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].e)>;
-                            using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
-                            if (element_0.e.count != 0) {
-                                auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.e.count);
-                                if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
-                                    return CHIP_ERROR_INVALID_ARGUMENT;
-                                }
-                                listFreer.add(listHolder_2);
-                                for (size_t i_2 = 0; i_2 < element_0.e.count; ++i_2) {
-                                    if (![element_0.e[i_2] isKindOfClass:[NSNumber class]]) {
-                                        // Wrong kind of value.
+                            {
+                                using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].e)>;
+                                using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
+                                if (element_0.e.count != 0) {
+                                    auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.e.count);
+                                    if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
                                         return CHIP_ERROR_INVALID_ARGUMENT;
                                     }
-                                    auto element_2 = (NSNumber *) element_0.e[i_2];
-                                    listHolder_2->mList[i_2] = element_2.unsignedIntValue;
+                                    listFreer.add(listHolder_2);
+                                    for (size_t i_2 = 0; i_2 < element_0.e.count; ++i_2) {
+                                        if (![element_0.e[i_2] isKindOfClass:[NSNumber class]]) {
+                                            // Wrong kind of value.
+                                            return CHIP_ERROR_INVALID_ARGUMENT;
+                                        }
+                                        auto element_2 = (NSNumber *) element_0.e[i_2];
+                                        listHolder_2->mList[i_2] = element_2.unsignedIntValue;
+                                    }
+                                    listHolder_0->mList[i_0].e = ListType_2(listHolder_2->mList, element_0.e.count);
+                                } else {
+                                    listHolder_0->mList[i_0].e = ListType_2();
                                 }
-                                listHolder_0->mList[i_0].e = ListType_2(listHolder_2->mList, element_0.e.count);
-                            } else {
-                                listHolder_0->mList[i_0].e = ListType_2();
                             }
-                        }
-                        {
-                            using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].f)>;
-                            using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
-                            if (element_0.f.count != 0) {
-                                auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.f.count);
-                                if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
-                                    return CHIP_ERROR_INVALID_ARGUMENT;
-                                }
-                                listFreer.add(listHolder_2);
-                                for (size_t i_2 = 0; i_2 < element_0.f.count; ++i_2) {
-                                    if (![element_0.f[i_2] isKindOfClass:[NSData class]]) {
-                                        // Wrong kind of value.
+                            {
+                                using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].f)>;
+                                using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
+                                if (element_0.f.count != 0) {
+                                    auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.f.count);
+                                    if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
                                         return CHIP_ERROR_INVALID_ARGUMENT;
                                     }
-                                    auto element_2 = (NSData *) element_0.f[i_2];
-                                    listHolder_2->mList[i_2] = [self asByteSpan:element_2];
+                                    listFreer.add(listHolder_2);
+                                    for (size_t i_2 = 0; i_2 < element_0.f.count; ++i_2) {
+                                        if (![element_0.f[i_2] isKindOfClass:[NSData class]]) {
+                                            // Wrong kind of value.
+                                            return CHIP_ERROR_INVALID_ARGUMENT;
+                                        }
+                                        auto element_2 = (NSData *) element_0.f[i_2];
+                                        listHolder_2->mList[i_2] = [self asByteSpan:element_2];
+                                    }
+                                    listHolder_0->mList[i_0].f = ListType_2(listHolder_2->mList, element_0.f.count);
+                                } else {
+                                    listHolder_0->mList[i_0].f = ListType_2();
                                 }
-                                listHolder_0->mList[i_0].f = ListType_2(listHolder_2->mList, element_0.f.count);
-                            } else {
-                                listHolder_0->mList[i_0].f = ListType_2();
                             }
-                        }
-                        {
-                            using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].g)>;
-                            using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
-                            if (element_0.g.count != 0) {
-                                auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.g.count);
-                                if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
-                                    return CHIP_ERROR_INVALID_ARGUMENT;
-                                }
-                                listFreer.add(listHolder_2);
-                                for (size_t i_2 = 0; i_2 < element_0.g.count; ++i_2) {
-                                    if (![element_0.g[i_2] isKindOfClass:[NSNumber class]]) {
-                                        // Wrong kind of value.
+                            {
+                                using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].g)>;
+                                using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
+                                if (element_0.g.count != 0) {
+                                    auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.g.count);
+                                    if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
                                         return CHIP_ERROR_INVALID_ARGUMENT;
                                     }
-                                    auto element_2 = (NSNumber *) element_0.g[i_2];
-                                    listHolder_2->mList[i_2] = element_2.unsignedCharValue;
+                                    listFreer.add(listHolder_2);
+                                    for (size_t i_2 = 0; i_2 < element_0.g.count; ++i_2) {
+                                        if (![element_0.g[i_2] isKindOfClass:[NSNumber class]]) {
+                                            // Wrong kind of value.
+                                            return CHIP_ERROR_INVALID_ARGUMENT;
+                                        }
+                                        auto element_2 = (NSNumber *) element_0.g[i_2];
+                                        listHolder_2->mList[i_2] = element_2.unsignedCharValue;
+                                    }
+                                    listHolder_0->mList[i_0].g = ListType_2(listHolder_2->mList, element_0.g.count);
+                                } else {
+                                    listHolder_0->mList[i_0].g = ListType_2();
                                 }
-                                listHolder_0->mList[i_0].g = ListType_2(listHolder_2->mList, element_0.g.count);
-                            } else {
-                                listHolder_0->mList[i_0].g = ListType_2();
                             }
                         }
+                        request.arg1 = ListType_0(listHolder_0->mList, params.arg1.count);
+                    } else {
+                        request.arg1 = ListType_0();
                     }
-                    request.arg1 = ListType_0(listHolder_0->mList, params.arg1.count);
-                } else {
-                    request.arg1 = ListType_0();
-                }
-            }
-            {
-                using ListType_0 = std::remove_reference_t<decltype(request.arg2)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (params.arg2.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.arg2.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < params.arg2.count; ++i_0) {
-                        if (![params.arg2[i_0] isKindOfClass:[MTRTestClusterClusterSimpleStruct class]]) {
-                            // Wrong kind of value.
+                }
+                {
+                    using ListType_0 = std::remove_reference_t<decltype(request.arg2)>;
+                    using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+                    if (params.arg2.count != 0) {
+                        auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.arg2.count);
+                        if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                             return CHIP_ERROR_INVALID_ARGUMENT;
                         }
-                        auto element_0 = (MTRTestClusterClusterSimpleStruct *) params.arg2[i_0];
-                        listHolder_0->mList[i_0].a = element_0.a.unsignedCharValue;
-                        listHolder_0->mList[i_0].b = element_0.b.boolValue;
-                        listHolder_0->mList[i_0].c = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].c)>>(
-                            element_0.c.unsignedCharValue);
-                        listHolder_0->mList[i_0].d = [self asByteSpan:element_0.d];
-                        listHolder_0->mList[i_0].e = [self asCharSpan:element_0.e];
-                        listHolder_0->mList[i_0].f = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].f)>>(
-                            element_0.f.unsignedCharValue);
-                        listHolder_0->mList[i_0].g = element_0.g.floatValue;
-                        listHolder_0->mList[i_0].h = element_0.h.doubleValue;
-                    }
-                    request.arg2 = ListType_0(listHolder_0->mList, params.arg2.count);
-                } else {
-                    request.arg2 = ListType_0();
-                }
-            }
-            {
-                using ListType_0 = std::remove_reference_t<decltype(request.arg3)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (params.arg3.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.arg3.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
+                        listFreer.add(listHolder_0);
+                        for (size_t i_0 = 0; i_0 < params.arg2.count; ++i_0) {
+                            if (![params.arg2[i_0] isKindOfClass:[MTRTestClusterClusterSimpleStruct class]]) {
+                                // Wrong kind of value.
+                                return CHIP_ERROR_INVALID_ARGUMENT;
+                            }
+                            auto element_0 = (MTRTestClusterClusterSimpleStruct *) params.arg2[i_0];
+                            listHolder_0->mList[i_0].a = element_0.a.unsignedCharValue;
+                            listHolder_0->mList[i_0].b = element_0.b.boolValue;
+                            listHolder_0->mList[i_0].c = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].c)>>(
+                                element_0.c.unsignedCharValue);
+                            listHolder_0->mList[i_0].d = [self asByteSpan:element_0.d];
+                            listHolder_0->mList[i_0].e = [self asCharSpan:element_0.e];
+                            listHolder_0->mList[i_0].f = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].f)>>(
+                                element_0.f.unsignedCharValue);
+                            listHolder_0->mList[i_0].g = element_0.g.floatValue;
+                            listHolder_0->mList[i_0].h = element_0.h.doubleValue;
+                        }
+                        request.arg2 = ListType_0(listHolder_0->mList, params.arg2.count);
+                    } else {
+                        request.arg2 = ListType_0();
                     }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < params.arg3.count; ++i_0) {
-                        if (![params.arg3[i_0] isKindOfClass:[NSNumber class]]) {
-                            // Wrong kind of value.
+                }
+                {
+                    using ListType_0 = std::remove_reference_t<decltype(request.arg3)>;
+                    using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+                    if (params.arg3.count != 0) {
+                        auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.arg3.count);
+                        if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                             return CHIP_ERROR_INVALID_ARGUMENT;
                         }
-                        auto element_0 = (NSNumber *) params.arg3[i_0];
-                        listHolder_0->mList[i_0]
-                            = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0])>>(element_0.unsignedCharValue);
-                    }
-                    request.arg3 = ListType_0(listHolder_0->mList, params.arg3.count);
-                } else {
-                    request.arg3 = ListType_0();
-                }
-            }
-            {
-                using ListType_0 = std::remove_reference_t<decltype(request.arg4)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (params.arg4.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.arg4.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
+                        listFreer.add(listHolder_0);
+                        for (size_t i_0 = 0; i_0 < params.arg3.count; ++i_0) {
+                            if (![params.arg3[i_0] isKindOfClass:[NSNumber class]]) {
+                                // Wrong kind of value.
+                                return CHIP_ERROR_INVALID_ARGUMENT;
+                            }
+                            auto element_0 = (NSNumber *) params.arg3[i_0];
+                            listHolder_0->mList[i_0] = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0])>>(
+                                element_0.unsignedCharValue);
+                        }
+                        request.arg3 = ListType_0(listHolder_0->mList, params.arg3.count);
+                    } else {
+                        request.arg3 = ListType_0();
                     }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < params.arg4.count; ++i_0) {
-                        if (![params.arg4[i_0] isKindOfClass:[NSNumber class]]) {
-                            // Wrong kind of value.
+                }
+                {
+                    using ListType_0 = std::remove_reference_t<decltype(request.arg4)>;
+                    using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+                    if (params.arg4.count != 0) {
+                        auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.arg4.count);
+                        if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                             return CHIP_ERROR_INVALID_ARGUMENT;
                         }
-                        auto element_0 = (NSNumber *) params.arg4[i_0];
-                        listHolder_0->mList[i_0] = element_0.boolValue;
+                        listFreer.add(listHolder_0);
+                        for (size_t i_0 = 0; i_0 < params.arg4.count; ++i_0) {
+                            if (![params.arg4[i_0] isKindOfClass:[NSNumber class]]) {
+                                // Wrong kind of value.
+                                return CHIP_ERROR_INVALID_ARGUMENT;
+                            }
+                            auto element_0 = (NSNumber *) params.arg4[i_0];
+                            listHolder_0->mList[i_0] = element_0.boolValue;
+                        }
+                        request.arg4 = ListType_0(listHolder_0->mList, params.arg4.count);
+                    } else {
+                        request.arg4 = ListType_0();
                     }
-                    request.arg4 = ListType_0(listHolder_0->mList, params.arg4.count);
-                } else {
-                    request.arg4 = ListType_0();
                 }
-            }
-            request.arg5 = static_cast<std::remove_reference_t<decltype(request.arg5)>>(params.arg5.unsignedCharValue);
-            request.arg6 = params.arg6.boolValue;
-
-            auto successFn = Callback<TestClusterClusterTestStructArrayArgumentResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.arg5 = static_cast<std::remove_reference_t<decltype(request.arg5)>>(params.arg5.unsignedCharValue);
+                request.arg6 = params.arg6.boolValue;
+
+                auto successFn = Callback<TestClusterClusterTestStructArrayArgumentResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)testStructArgumentRequestWithParams:(MTRTestClusterClusterTestStructArgumentRequestParams *)params
@@ -18810,33 +21685,49 @@ - (void)testStructArgumentRequestWithParams:(MTRTestClusterClusterTestStructArgu
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::TestStructArgumentRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.arg1.a = params.arg1.a.unsignedCharValue;
-            request.arg1.b = params.arg1.b.boolValue;
-            request.arg1.c = static_cast<std::remove_reference_t<decltype(request.arg1.c)>>(params.arg1.c.unsignedCharValue);
-            request.arg1.d = [self asByteSpan:params.arg1.d];
-            request.arg1.e = [self asCharSpan:params.arg1.e];
-            request.arg1.f = static_cast<std::remove_reference_t<decltype(request.arg1.f)>>(params.arg1.f.unsignedCharValue);
-            request.arg1.g = params.arg1.g.floatValue;
-            request.arg1.h = params.arg1.h.doubleValue;
-
-            auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::TestStructArgumentRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.arg1.a = params.arg1.a.unsignedCharValue;
+                request.arg1.b = params.arg1.b.boolValue;
+                request.arg1.c = static_cast<std::remove_reference_t<decltype(request.arg1.c)>>(params.arg1.c.unsignedCharValue);
+                request.arg1.d = [self asByteSpan:params.arg1.d];
+                request.arg1.e = [self asCharSpan:params.arg1.e];
+                request.arg1.f = static_cast<std::remove_reference_t<decltype(request.arg1.f)>>(params.arg1.f.unsignedCharValue);
+                request.arg1.g = params.arg1.g.floatValue;
+                request.arg1.h = params.arg1.h.doubleValue;
+
+                auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)testNestedStructArgumentRequestWithParams:(MTRTestClusterClusterTestNestedStructArgumentRequestParams *)params
@@ -18847,35 +21738,53 @@ - (void)testNestedStructArgumentRequestWithParams:(MTRTestClusterClusterTestNest
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::TestNestedStructArgumentRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.arg1.a = params.arg1.a.unsignedCharValue;
-            request.arg1.b = params.arg1.b.boolValue;
-            request.arg1.c.a = params.arg1.c.a.unsignedCharValue;
-            request.arg1.c.b = params.arg1.c.b.boolValue;
-            request.arg1.c.c = static_cast<std::remove_reference_t<decltype(request.arg1.c.c)>>(params.arg1.c.c.unsignedCharValue);
-            request.arg1.c.d = [self asByteSpan:params.arg1.c.d];
-            request.arg1.c.e = [self asCharSpan:params.arg1.c.e];
-            request.arg1.c.f = static_cast<std::remove_reference_t<decltype(request.arg1.c.f)>>(params.arg1.c.f.unsignedCharValue);
-            request.arg1.c.g = params.arg1.c.g.floatValue;
-            request.arg1.c.h = params.arg1.c.h.doubleValue;
-
-            auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::TestNestedStructArgumentRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.arg1.a = params.arg1.a.unsignedCharValue;
+                request.arg1.b = params.arg1.b.boolValue;
+                request.arg1.c.a = params.arg1.c.a.unsignedCharValue;
+                request.arg1.c.b = params.arg1.c.b.boolValue;
+                request.arg1.c.c
+                    = static_cast<std::remove_reference_t<decltype(request.arg1.c.c)>>(params.arg1.c.c.unsignedCharValue);
+                request.arg1.c.d = [self asByteSpan:params.arg1.c.d];
+                request.arg1.c.e = [self asCharSpan:params.arg1.c.e];
+                request.arg1.c.f
+                    = static_cast<std::remove_reference_t<decltype(request.arg1.c.f)>>(params.arg1.c.f.unsignedCharValue);
+                request.arg1.c.g = params.arg1.c.g.floatValue;
+                request.arg1.c.h = params.arg1.c.h.doubleValue;
+
+                auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)testListStructArgumentRequestWithParams:(MTRTestClusterClusterTestListStructArgumentRequestParams *)params
@@ -18886,56 +21795,72 @@ - (void)testListStructArgumentRequestWithParams:(MTRTestClusterClusterTestListSt
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::TestListStructArgumentRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            {
-                using ListType_0 = std::remove_reference_t<decltype(request.arg1)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (params.arg1.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.arg1.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < params.arg1.count; ++i_0) {
-                        if (![params.arg1[i_0] isKindOfClass:[MTRTestClusterClusterSimpleStruct class]]) {
-                            // Wrong kind of value.
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::TestListStructArgumentRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                {
+                    using ListType_0 = std::remove_reference_t<decltype(request.arg1)>;
+                    using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+                    if (params.arg1.count != 0) {
+                        auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.arg1.count);
+                        if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                             return CHIP_ERROR_INVALID_ARGUMENT;
                         }
-                        auto element_0 = (MTRTestClusterClusterSimpleStruct *) params.arg1[i_0];
-                        listHolder_0->mList[i_0].a = element_0.a.unsignedCharValue;
-                        listHolder_0->mList[i_0].b = element_0.b.boolValue;
-                        listHolder_0->mList[i_0].c = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].c)>>(
-                            element_0.c.unsignedCharValue);
-                        listHolder_0->mList[i_0].d = [self asByteSpan:element_0.d];
-                        listHolder_0->mList[i_0].e = [self asCharSpan:element_0.e];
-                        listHolder_0->mList[i_0].f = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].f)>>(
-                            element_0.f.unsignedCharValue);
-                        listHolder_0->mList[i_0].g = element_0.g.floatValue;
-                        listHolder_0->mList[i_0].h = element_0.h.doubleValue;
+                        listFreer.add(listHolder_0);
+                        for (size_t i_0 = 0; i_0 < params.arg1.count; ++i_0) {
+                            if (![params.arg1[i_0] isKindOfClass:[MTRTestClusterClusterSimpleStruct class]]) {
+                                // Wrong kind of value.
+                                return CHIP_ERROR_INVALID_ARGUMENT;
+                            }
+                            auto element_0 = (MTRTestClusterClusterSimpleStruct *) params.arg1[i_0];
+                            listHolder_0->mList[i_0].a = element_0.a.unsignedCharValue;
+                            listHolder_0->mList[i_0].b = element_0.b.boolValue;
+                            listHolder_0->mList[i_0].c = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].c)>>(
+                                element_0.c.unsignedCharValue);
+                            listHolder_0->mList[i_0].d = [self asByteSpan:element_0.d];
+                            listHolder_0->mList[i_0].e = [self asCharSpan:element_0.e];
+                            listHolder_0->mList[i_0].f = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].f)>>(
+                                element_0.f.unsignedCharValue);
+                            listHolder_0->mList[i_0].g = element_0.g.floatValue;
+                            listHolder_0->mList[i_0].h = element_0.h.doubleValue;
+                        }
+                        request.arg1 = ListType_0(listHolder_0->mList, params.arg1.count);
+                    } else {
+                        request.arg1 = ListType_0();
                     }
-                    request.arg1 = ListType_0(listHolder_0->mList, params.arg1.count);
-                } else {
-                    request.arg1 = ListType_0();
                 }
-            }
-
-            auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
 
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)testListInt8UArgumentRequestWithParams:(MTRTestClusterClusterTestListInt8UArgumentRequestParams *)params
@@ -18946,47 +21871,63 @@ - (void)testListInt8UArgumentRequestWithParams:(MTRTestClusterClusterTestListInt
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::TestListInt8UArgumentRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            {
-                using ListType_0 = std::remove_reference_t<decltype(request.arg1)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (params.arg1.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.arg1.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < params.arg1.count; ++i_0) {
-                        if (![params.arg1[i_0] isKindOfClass:[NSNumber class]]) {
-                            // Wrong kind of value.
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::TestListInt8UArgumentRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                {
+                    using ListType_0 = std::remove_reference_t<decltype(request.arg1)>;
+                    using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+                    if (params.arg1.count != 0) {
+                        auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.arg1.count);
+                        if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                             return CHIP_ERROR_INVALID_ARGUMENT;
                         }
-                        auto element_0 = (NSNumber *) params.arg1[i_0];
-                        listHolder_0->mList[i_0] = element_0.unsignedCharValue;
+                        listFreer.add(listHolder_0);
+                        for (size_t i_0 = 0; i_0 < params.arg1.count; ++i_0) {
+                            if (![params.arg1[i_0] isKindOfClass:[NSNumber class]]) {
+                                // Wrong kind of value.
+                                return CHIP_ERROR_INVALID_ARGUMENT;
+                            }
+                            auto element_0 = (NSNumber *) params.arg1[i_0];
+                            listHolder_0->mList[i_0] = element_0.unsignedCharValue;
+                        }
+                        request.arg1 = ListType_0(listHolder_0->mList, params.arg1.count);
+                    } else {
+                        request.arg1 = ListType_0();
                     }
-                    request.arg1 = ListType_0(listHolder_0->mList, params.arg1.count);
-                } else {
-                    request.arg1 = ListType_0();
                 }
-            }
-
-            auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
 
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)testNestedStructListArgumentRequestWithParams:(MTRTestClusterClusterTestNestedStructListArgumentRequestParams *)params
@@ -18997,132 +21938,150 @@ - (void)testNestedStructListArgumentRequestWithParams:(MTRTestClusterClusterTest
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::TestNestedStructListArgumentRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.arg1.a = params.arg1.a.unsignedCharValue;
-            request.arg1.b = params.arg1.b.boolValue;
-            request.arg1.c.a = params.arg1.c.a.unsignedCharValue;
-            request.arg1.c.b = params.arg1.c.b.boolValue;
-            request.arg1.c.c = static_cast<std::remove_reference_t<decltype(request.arg1.c.c)>>(params.arg1.c.c.unsignedCharValue);
-            request.arg1.c.d = [self asByteSpan:params.arg1.c.d];
-            request.arg1.c.e = [self asCharSpan:params.arg1.c.e];
-            request.arg1.c.f = static_cast<std::remove_reference_t<decltype(request.arg1.c.f)>>(params.arg1.c.f.unsignedCharValue);
-            request.arg1.c.g = params.arg1.c.g.floatValue;
-            request.arg1.c.h = params.arg1.c.h.doubleValue;
-            {
-                using ListType_1 = std::remove_reference_t<decltype(request.arg1.d)>;
-                using ListMemberType_1 = ListMemberTypeGetter<ListType_1>::Type;
-                if (params.arg1.d.count != 0) {
-                    auto * listHolder_1 = new ListHolder<ListMemberType_1>(params.arg1.d.count);
-                    if (listHolder_1 == nullptr || listHolder_1->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_1);
-                    for (size_t i_1 = 0; i_1 < params.arg1.d.count; ++i_1) {
-                        if (![params.arg1.d[i_1] isKindOfClass:[MTRTestClusterClusterSimpleStruct class]]) {
-                            // Wrong kind of value.
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::TestNestedStructListArgumentRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.arg1.a = params.arg1.a.unsignedCharValue;
+                request.arg1.b = params.arg1.b.boolValue;
+                request.arg1.c.a = params.arg1.c.a.unsignedCharValue;
+                request.arg1.c.b = params.arg1.c.b.boolValue;
+                request.arg1.c.c
+                    = static_cast<std::remove_reference_t<decltype(request.arg1.c.c)>>(params.arg1.c.c.unsignedCharValue);
+                request.arg1.c.d = [self asByteSpan:params.arg1.c.d];
+                request.arg1.c.e = [self asCharSpan:params.arg1.c.e];
+                request.arg1.c.f
+                    = static_cast<std::remove_reference_t<decltype(request.arg1.c.f)>>(params.arg1.c.f.unsignedCharValue);
+                request.arg1.c.g = params.arg1.c.g.floatValue;
+                request.arg1.c.h = params.arg1.c.h.doubleValue;
+                {
+                    using ListType_1 = std::remove_reference_t<decltype(request.arg1.d)>;
+                    using ListMemberType_1 = ListMemberTypeGetter<ListType_1>::Type;
+                    if (params.arg1.d.count != 0) {
+                        auto * listHolder_1 = new ListHolder<ListMemberType_1>(params.arg1.d.count);
+                        if (listHolder_1 == nullptr || listHolder_1->mList == nullptr) {
                             return CHIP_ERROR_INVALID_ARGUMENT;
                         }
-                        auto element_1 = (MTRTestClusterClusterSimpleStruct *) params.arg1.d[i_1];
-                        listHolder_1->mList[i_1].a = element_1.a.unsignedCharValue;
-                        listHolder_1->mList[i_1].b = element_1.b.boolValue;
-                        listHolder_1->mList[i_1].c = static_cast<std::remove_reference_t<decltype(listHolder_1->mList[i_1].c)>>(
-                            element_1.c.unsignedCharValue);
-                        listHolder_1->mList[i_1].d = [self asByteSpan:element_1.d];
-                        listHolder_1->mList[i_1].e = [self asCharSpan:element_1.e];
-                        listHolder_1->mList[i_1].f = static_cast<std::remove_reference_t<decltype(listHolder_1->mList[i_1].f)>>(
-                            element_1.f.unsignedCharValue);
-                        listHolder_1->mList[i_1].g = element_1.g.floatValue;
-                        listHolder_1->mList[i_1].h = element_1.h.doubleValue;
-                    }
-                    request.arg1.d = ListType_1(listHolder_1->mList, params.arg1.d.count);
-                } else {
-                    request.arg1.d = ListType_1();
-                }
-            }
-            {
-                using ListType_1 = std::remove_reference_t<decltype(request.arg1.e)>;
-                using ListMemberType_1 = ListMemberTypeGetter<ListType_1>::Type;
-                if (params.arg1.e.count != 0) {
-                    auto * listHolder_1 = new ListHolder<ListMemberType_1>(params.arg1.e.count);
-                    if (listHolder_1 == nullptr || listHolder_1->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
+                        listFreer.add(listHolder_1);
+                        for (size_t i_1 = 0; i_1 < params.arg1.d.count; ++i_1) {
+                            if (![params.arg1.d[i_1] isKindOfClass:[MTRTestClusterClusterSimpleStruct class]]) {
+                                // Wrong kind of value.
+                                return CHIP_ERROR_INVALID_ARGUMENT;
+                            }
+                            auto element_1 = (MTRTestClusterClusterSimpleStruct *) params.arg1.d[i_1];
+                            listHolder_1->mList[i_1].a = element_1.a.unsignedCharValue;
+                            listHolder_1->mList[i_1].b = element_1.b.boolValue;
+                            listHolder_1->mList[i_1].c = static_cast<std::remove_reference_t<decltype(listHolder_1->mList[i_1].c)>>(
+                                element_1.c.unsignedCharValue);
+                            listHolder_1->mList[i_1].d = [self asByteSpan:element_1.d];
+                            listHolder_1->mList[i_1].e = [self asCharSpan:element_1.e];
+                            listHolder_1->mList[i_1].f = static_cast<std::remove_reference_t<decltype(listHolder_1->mList[i_1].f)>>(
+                                element_1.f.unsignedCharValue);
+                            listHolder_1->mList[i_1].g = element_1.g.floatValue;
+                            listHolder_1->mList[i_1].h = element_1.h.doubleValue;
+                        }
+                        request.arg1.d = ListType_1(listHolder_1->mList, params.arg1.d.count);
+                    } else {
+                        request.arg1.d = ListType_1();
                     }
-                    listFreer.add(listHolder_1);
-                    for (size_t i_1 = 0; i_1 < params.arg1.e.count; ++i_1) {
-                        if (![params.arg1.e[i_1] isKindOfClass:[NSNumber class]]) {
-                            // Wrong kind of value.
+                }
+                {
+                    using ListType_1 = std::remove_reference_t<decltype(request.arg1.e)>;
+                    using ListMemberType_1 = ListMemberTypeGetter<ListType_1>::Type;
+                    if (params.arg1.e.count != 0) {
+                        auto * listHolder_1 = new ListHolder<ListMemberType_1>(params.arg1.e.count);
+                        if (listHolder_1 == nullptr || listHolder_1->mList == nullptr) {
                             return CHIP_ERROR_INVALID_ARGUMENT;
                         }
-                        auto element_1 = (NSNumber *) params.arg1.e[i_1];
-                        listHolder_1->mList[i_1] = element_1.unsignedIntValue;
-                    }
-                    request.arg1.e = ListType_1(listHolder_1->mList, params.arg1.e.count);
-                } else {
-                    request.arg1.e = ListType_1();
-                }
-            }
-            {
-                using ListType_1 = std::remove_reference_t<decltype(request.arg1.f)>;
-                using ListMemberType_1 = ListMemberTypeGetter<ListType_1>::Type;
-                if (params.arg1.f.count != 0) {
-                    auto * listHolder_1 = new ListHolder<ListMemberType_1>(params.arg1.f.count);
-                    if (listHolder_1 == nullptr || listHolder_1->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
+                        listFreer.add(listHolder_1);
+                        for (size_t i_1 = 0; i_1 < params.arg1.e.count; ++i_1) {
+                            if (![params.arg1.e[i_1] isKindOfClass:[NSNumber class]]) {
+                                // Wrong kind of value.
+                                return CHIP_ERROR_INVALID_ARGUMENT;
+                            }
+                            auto element_1 = (NSNumber *) params.arg1.e[i_1];
+                            listHolder_1->mList[i_1] = element_1.unsignedIntValue;
+                        }
+                        request.arg1.e = ListType_1(listHolder_1->mList, params.arg1.e.count);
+                    } else {
+                        request.arg1.e = ListType_1();
                     }
-                    listFreer.add(listHolder_1);
-                    for (size_t i_1 = 0; i_1 < params.arg1.f.count; ++i_1) {
-                        if (![params.arg1.f[i_1] isKindOfClass:[NSData class]]) {
-                            // Wrong kind of value.
+                }
+                {
+                    using ListType_1 = std::remove_reference_t<decltype(request.arg1.f)>;
+                    using ListMemberType_1 = ListMemberTypeGetter<ListType_1>::Type;
+                    if (params.arg1.f.count != 0) {
+                        auto * listHolder_1 = new ListHolder<ListMemberType_1>(params.arg1.f.count);
+                        if (listHolder_1 == nullptr || listHolder_1->mList == nullptr) {
                             return CHIP_ERROR_INVALID_ARGUMENT;
                         }
-                        auto element_1 = (NSData *) params.arg1.f[i_1];
-                        listHolder_1->mList[i_1] = [self asByteSpan:element_1];
-                    }
-                    request.arg1.f = ListType_1(listHolder_1->mList, params.arg1.f.count);
-                } else {
-                    request.arg1.f = ListType_1();
-                }
-            }
-            {
-                using ListType_1 = std::remove_reference_t<decltype(request.arg1.g)>;
-                using ListMemberType_1 = ListMemberTypeGetter<ListType_1>::Type;
-                if (params.arg1.g.count != 0) {
-                    auto * listHolder_1 = new ListHolder<ListMemberType_1>(params.arg1.g.count);
-                    if (listHolder_1 == nullptr || listHolder_1->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
+                        listFreer.add(listHolder_1);
+                        for (size_t i_1 = 0; i_1 < params.arg1.f.count; ++i_1) {
+                            if (![params.arg1.f[i_1] isKindOfClass:[NSData class]]) {
+                                // Wrong kind of value.
+                                return CHIP_ERROR_INVALID_ARGUMENT;
+                            }
+                            auto element_1 = (NSData *) params.arg1.f[i_1];
+                            listHolder_1->mList[i_1] = [self asByteSpan:element_1];
+                        }
+                        request.arg1.f = ListType_1(listHolder_1->mList, params.arg1.f.count);
+                    } else {
+                        request.arg1.f = ListType_1();
                     }
-                    listFreer.add(listHolder_1);
-                    for (size_t i_1 = 0; i_1 < params.arg1.g.count; ++i_1) {
-                        if (![params.arg1.g[i_1] isKindOfClass:[NSNumber class]]) {
-                            // Wrong kind of value.
+                }
+                {
+                    using ListType_1 = std::remove_reference_t<decltype(request.arg1.g)>;
+                    using ListMemberType_1 = ListMemberTypeGetter<ListType_1>::Type;
+                    if (params.arg1.g.count != 0) {
+                        auto * listHolder_1 = new ListHolder<ListMemberType_1>(params.arg1.g.count);
+                        if (listHolder_1 == nullptr || listHolder_1->mList == nullptr) {
                             return CHIP_ERROR_INVALID_ARGUMENT;
                         }
-                        auto element_1 = (NSNumber *) params.arg1.g[i_1];
-                        listHolder_1->mList[i_1] = element_1.unsignedCharValue;
+                        listFreer.add(listHolder_1);
+                        for (size_t i_1 = 0; i_1 < params.arg1.g.count; ++i_1) {
+                            if (![params.arg1.g[i_1] isKindOfClass:[NSNumber class]]) {
+                                // Wrong kind of value.
+                                return CHIP_ERROR_INVALID_ARGUMENT;
+                            }
+                            auto element_1 = (NSNumber *) params.arg1.g[i_1];
+                            listHolder_1->mList[i_1] = element_1.unsignedCharValue;
+                        }
+                        request.arg1.g = ListType_1(listHolder_1->mList, params.arg1.g.count);
+                    } else {
+                        request.arg1.g = ListType_1();
                     }
-                    request.arg1.g = ListType_1(listHolder_1->mList, params.arg1.g.count);
-                } else {
-                    request.arg1.g = ListType_1();
                 }
-            }
 
-            auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)testListNestedStructListArgumentRequestWithParams:
@@ -19134,157 +22093,175 @@ - (void)testListNestedStructListArgumentRequestWithParams:
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::TestListNestedStructListArgumentRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            {
-                using ListType_0 = std::remove_reference_t<decltype(request.arg1)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (params.arg1.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.arg1.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < params.arg1.count; ++i_0) {
-                        if (![params.arg1[i_0] isKindOfClass:[MTRTestClusterClusterNestedStructList class]]) {
-                            // Wrong kind of value.
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::TestListNestedStructListArgumentRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                {
+                    using ListType_0 = std::remove_reference_t<decltype(request.arg1)>;
+                    using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+                    if (params.arg1.count != 0) {
+                        auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.arg1.count);
+                        if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                             return CHIP_ERROR_INVALID_ARGUMENT;
                         }
-                        auto element_0 = (MTRTestClusterClusterNestedStructList *) params.arg1[i_0];
-                        listHolder_0->mList[i_0].a = element_0.a.unsignedCharValue;
-                        listHolder_0->mList[i_0].b = element_0.b.boolValue;
-                        listHolder_0->mList[i_0].c.a = element_0.c.a.unsignedCharValue;
-                        listHolder_0->mList[i_0].c.b = element_0.c.b.boolValue;
-                        listHolder_0->mList[i_0].c.c = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].c.c)>>(
-                            element_0.c.c.unsignedCharValue);
-                        listHolder_0->mList[i_0].c.d = [self asByteSpan:element_0.c.d];
-                        listHolder_0->mList[i_0].c.e = [self asCharSpan:element_0.c.e];
-                        listHolder_0->mList[i_0].c.f = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].c.f)>>(
-                            element_0.c.f.unsignedCharValue);
-                        listHolder_0->mList[i_0].c.g = element_0.c.g.floatValue;
-                        listHolder_0->mList[i_0].c.h = element_0.c.h.doubleValue;
-                        {
-                            using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].d)>;
-                            using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
-                            if (element_0.d.count != 0) {
-                                auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.d.count);
-                                if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
-                                    return CHIP_ERROR_INVALID_ARGUMENT;
-                                }
-                                listFreer.add(listHolder_2);
-                                for (size_t i_2 = 0; i_2 < element_0.d.count; ++i_2) {
-                                    if (![element_0.d[i_2] isKindOfClass:[MTRTestClusterClusterSimpleStruct class]]) {
-                                        // Wrong kind of value.
+                        listFreer.add(listHolder_0);
+                        for (size_t i_0 = 0; i_0 < params.arg1.count; ++i_0) {
+                            if (![params.arg1[i_0] isKindOfClass:[MTRTestClusterClusterNestedStructList class]]) {
+                                // Wrong kind of value.
+                                return CHIP_ERROR_INVALID_ARGUMENT;
+                            }
+                            auto element_0 = (MTRTestClusterClusterNestedStructList *) params.arg1[i_0];
+                            listHolder_0->mList[i_0].a = element_0.a.unsignedCharValue;
+                            listHolder_0->mList[i_0].b = element_0.b.boolValue;
+                            listHolder_0->mList[i_0].c.a = element_0.c.a.unsignedCharValue;
+                            listHolder_0->mList[i_0].c.b = element_0.c.b.boolValue;
+                            listHolder_0->mList[i_0].c.c
+                                = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].c.c)>>(
+                                    element_0.c.c.unsignedCharValue);
+                            listHolder_0->mList[i_0].c.d = [self asByteSpan:element_0.c.d];
+                            listHolder_0->mList[i_0].c.e = [self asCharSpan:element_0.c.e];
+                            listHolder_0->mList[i_0].c.f
+                                = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].c.f)>>(
+                                    element_0.c.f.unsignedCharValue);
+                            listHolder_0->mList[i_0].c.g = element_0.c.g.floatValue;
+                            listHolder_0->mList[i_0].c.h = element_0.c.h.doubleValue;
+                            {
+                                using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].d)>;
+                                using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
+                                if (element_0.d.count != 0) {
+                                    auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.d.count);
+                                    if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
                                         return CHIP_ERROR_INVALID_ARGUMENT;
                                     }
-                                    auto element_2 = (MTRTestClusterClusterSimpleStruct *) element_0.d[i_2];
-                                    listHolder_2->mList[i_2].a = element_2.a.unsignedCharValue;
-                                    listHolder_2->mList[i_2].b = element_2.b.boolValue;
-                                    listHolder_2->mList[i_2].c
-                                        = static_cast<std::remove_reference_t<decltype(listHolder_2->mList[i_2].c)>>(
-                                            element_2.c.unsignedCharValue);
-                                    listHolder_2->mList[i_2].d = [self asByteSpan:element_2.d];
-                                    listHolder_2->mList[i_2].e = [self asCharSpan:element_2.e];
-                                    listHolder_2->mList[i_2].f
-                                        = static_cast<std::remove_reference_t<decltype(listHolder_2->mList[i_2].f)>>(
-                                            element_2.f.unsignedCharValue);
-                                    listHolder_2->mList[i_2].g = element_2.g.floatValue;
-                                    listHolder_2->mList[i_2].h = element_2.h.doubleValue;
+                                    listFreer.add(listHolder_2);
+                                    for (size_t i_2 = 0; i_2 < element_0.d.count; ++i_2) {
+                                        if (![element_0.d[i_2] isKindOfClass:[MTRTestClusterClusterSimpleStruct class]]) {
+                                            // Wrong kind of value.
+                                            return CHIP_ERROR_INVALID_ARGUMENT;
+                                        }
+                                        auto element_2 = (MTRTestClusterClusterSimpleStruct *) element_0.d[i_2];
+                                        listHolder_2->mList[i_2].a = element_2.a.unsignedCharValue;
+                                        listHolder_2->mList[i_2].b = element_2.b.boolValue;
+                                        listHolder_2->mList[i_2].c
+                                            = static_cast<std::remove_reference_t<decltype(listHolder_2->mList[i_2].c)>>(
+                                                element_2.c.unsignedCharValue);
+                                        listHolder_2->mList[i_2].d = [self asByteSpan:element_2.d];
+                                        listHolder_2->mList[i_2].e = [self asCharSpan:element_2.e];
+                                        listHolder_2->mList[i_2].f
+                                            = static_cast<std::remove_reference_t<decltype(listHolder_2->mList[i_2].f)>>(
+                                                element_2.f.unsignedCharValue);
+                                        listHolder_2->mList[i_2].g = element_2.g.floatValue;
+                                        listHolder_2->mList[i_2].h = element_2.h.doubleValue;
+                                    }
+                                    listHolder_0->mList[i_0].d = ListType_2(listHolder_2->mList, element_0.d.count);
+                                } else {
+                                    listHolder_0->mList[i_0].d = ListType_2();
                                 }
-                                listHolder_0->mList[i_0].d = ListType_2(listHolder_2->mList, element_0.d.count);
-                            } else {
-                                listHolder_0->mList[i_0].d = ListType_2();
                             }
-                        }
-                        {
-                            using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].e)>;
-                            using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
-                            if (element_0.e.count != 0) {
-                                auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.e.count);
-                                if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
-                                    return CHIP_ERROR_INVALID_ARGUMENT;
-                                }
-                                listFreer.add(listHolder_2);
-                                for (size_t i_2 = 0; i_2 < element_0.e.count; ++i_2) {
-                                    if (![element_0.e[i_2] isKindOfClass:[NSNumber class]]) {
-                                        // Wrong kind of value.
+                            {
+                                using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].e)>;
+                                using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
+                                if (element_0.e.count != 0) {
+                                    auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.e.count);
+                                    if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
                                         return CHIP_ERROR_INVALID_ARGUMENT;
                                     }
-                                    auto element_2 = (NSNumber *) element_0.e[i_2];
-                                    listHolder_2->mList[i_2] = element_2.unsignedIntValue;
+                                    listFreer.add(listHolder_2);
+                                    for (size_t i_2 = 0; i_2 < element_0.e.count; ++i_2) {
+                                        if (![element_0.e[i_2] isKindOfClass:[NSNumber class]]) {
+                                            // Wrong kind of value.
+                                            return CHIP_ERROR_INVALID_ARGUMENT;
+                                        }
+                                        auto element_2 = (NSNumber *) element_0.e[i_2];
+                                        listHolder_2->mList[i_2] = element_2.unsignedIntValue;
+                                    }
+                                    listHolder_0->mList[i_0].e = ListType_2(listHolder_2->mList, element_0.e.count);
+                                } else {
+                                    listHolder_0->mList[i_0].e = ListType_2();
                                 }
-                                listHolder_0->mList[i_0].e = ListType_2(listHolder_2->mList, element_0.e.count);
-                            } else {
-                                listHolder_0->mList[i_0].e = ListType_2();
                             }
-                        }
-                        {
-                            using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].f)>;
-                            using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
-                            if (element_0.f.count != 0) {
-                                auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.f.count);
-                                if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
-                                    return CHIP_ERROR_INVALID_ARGUMENT;
-                                }
-                                listFreer.add(listHolder_2);
-                                for (size_t i_2 = 0; i_2 < element_0.f.count; ++i_2) {
-                                    if (![element_0.f[i_2] isKindOfClass:[NSData class]]) {
-                                        // Wrong kind of value.
+                            {
+                                using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].f)>;
+                                using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
+                                if (element_0.f.count != 0) {
+                                    auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.f.count);
+                                    if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
                                         return CHIP_ERROR_INVALID_ARGUMENT;
                                     }
-                                    auto element_2 = (NSData *) element_0.f[i_2];
-                                    listHolder_2->mList[i_2] = [self asByteSpan:element_2];
+                                    listFreer.add(listHolder_2);
+                                    for (size_t i_2 = 0; i_2 < element_0.f.count; ++i_2) {
+                                        if (![element_0.f[i_2] isKindOfClass:[NSData class]]) {
+                                            // Wrong kind of value.
+                                            return CHIP_ERROR_INVALID_ARGUMENT;
+                                        }
+                                        auto element_2 = (NSData *) element_0.f[i_2];
+                                        listHolder_2->mList[i_2] = [self asByteSpan:element_2];
+                                    }
+                                    listHolder_0->mList[i_0].f = ListType_2(listHolder_2->mList, element_0.f.count);
+                                } else {
+                                    listHolder_0->mList[i_0].f = ListType_2();
                                 }
-                                listHolder_0->mList[i_0].f = ListType_2(listHolder_2->mList, element_0.f.count);
-                            } else {
-                                listHolder_0->mList[i_0].f = ListType_2();
                             }
-                        }
-                        {
-                            using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].g)>;
-                            using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
-                            if (element_0.g.count != 0) {
-                                auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.g.count);
-                                if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
-                                    return CHIP_ERROR_INVALID_ARGUMENT;
-                                }
-                                listFreer.add(listHolder_2);
-                                for (size_t i_2 = 0; i_2 < element_0.g.count; ++i_2) {
-                                    if (![element_0.g[i_2] isKindOfClass:[NSNumber class]]) {
-                                        // Wrong kind of value.
+                            {
+                                using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].g)>;
+                                using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
+                                if (element_0.g.count != 0) {
+                                    auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.g.count);
+                                    if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
                                         return CHIP_ERROR_INVALID_ARGUMENT;
                                     }
-                                    auto element_2 = (NSNumber *) element_0.g[i_2];
-                                    listHolder_2->mList[i_2] = element_2.unsignedCharValue;
+                                    listFreer.add(listHolder_2);
+                                    for (size_t i_2 = 0; i_2 < element_0.g.count; ++i_2) {
+                                        if (![element_0.g[i_2] isKindOfClass:[NSNumber class]]) {
+                                            // Wrong kind of value.
+                                            return CHIP_ERROR_INVALID_ARGUMENT;
+                                        }
+                                        auto element_2 = (NSNumber *) element_0.g[i_2];
+                                        listHolder_2->mList[i_2] = element_2.unsignedCharValue;
+                                    }
+                                    listHolder_0->mList[i_0].g = ListType_2(listHolder_2->mList, element_0.g.count);
+                                } else {
+                                    listHolder_0->mList[i_0].g = ListType_2();
                                 }
-                                listHolder_0->mList[i_0].g = ListType_2(listHolder_2->mList, element_0.g.count);
-                            } else {
-                                listHolder_0->mList[i_0].g = ListType_2();
                             }
                         }
+                        request.arg1 = ListType_0(listHolder_0->mList, params.arg1.count);
+                    } else {
+                        request.arg1 = ListType_0();
                     }
-                    request.arg1 = ListType_0(listHolder_0->mList, params.arg1.count);
-                } else {
-                    request.arg1 = ListType_0();
                 }
-            }
-
-            auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
 
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<TestClusterClusterBooleanResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)testListInt8UReverseRequestWithParams:(MTRTestClusterClusterTestListInt8UReverseRequestParams *)params
@@ -19295,47 +22272,63 @@ - (void)testListInt8UReverseRequestWithParams:(MTRTestClusterClusterTestListInt8
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRTestClusterClusterTestListInt8UReverseResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::TestListInt8UReverseRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            {
-                using ListType_0 = std::remove_reference_t<decltype(request.arg1)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (params.arg1.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.arg1.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < params.arg1.count; ++i_0) {
-                        if (![params.arg1[i_0] isKindOfClass:[NSNumber class]]) {
-                            // Wrong kind of value.
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRTestClusterClusterTestListInt8UReverseResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::TestListInt8UReverseRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                {
+                    using ListType_0 = std::remove_reference_t<decltype(request.arg1)>;
+                    using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+                    if (params.arg1.count != 0) {
+                        auto * listHolder_0 = new ListHolder<ListMemberType_0>(params.arg1.count);
+                        if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                             return CHIP_ERROR_INVALID_ARGUMENT;
                         }
-                        auto element_0 = (NSNumber *) params.arg1[i_0];
-                        listHolder_0->mList[i_0] = element_0.unsignedCharValue;
+                        listFreer.add(listHolder_0);
+                        for (size_t i_0 = 0; i_0 < params.arg1.count; ++i_0) {
+                            if (![params.arg1[i_0] isKindOfClass:[NSNumber class]]) {
+                                // Wrong kind of value.
+                                return CHIP_ERROR_INVALID_ARGUMENT;
+                            }
+                            auto element_0 = (NSNumber *) params.arg1[i_0];
+                            listHolder_0->mList[i_0] = element_0.unsignedCharValue;
+                        }
+                        request.arg1 = ListType_0(listHolder_0->mList, params.arg1.count);
+                    } else {
+                        request.arg1 = ListType_0();
                     }
-                    request.arg1 = ListType_0(listHolder_0->mList, params.arg1.count);
-                } else {
-                    request.arg1 = ListType_0();
                 }
-            }
 
-            auto successFn = Callback<TestClusterClusterTestListInt8UReverseResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<TestClusterClusterTestListInt8UReverseResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)testEnumsRequestWithParams:(MTRTestClusterClusterTestEnumsRequestParams *)params
@@ -19346,27 +22339,43 @@ - (void)testEnumsRequestWithParams:(MTRTestClusterClusterTestEnumsRequestParams
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRTestClusterClusterTestEnumsResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::TestEnumsRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRTestClusterClusterTestEnumsResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::TestEnumsRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
                 }
-            }
-            request.arg1 = static_cast<std::remove_reference_t<decltype(request.arg1)>>(params.arg1.unsignedShortValue);
-            request.arg2 = static_cast<std::remove_reference_t<decltype(request.arg2)>>(params.arg2.unsignedCharValue);
-
-            auto successFn = Callback<TestClusterClusterTestEnumsResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                request.arg1 = static_cast<std::remove_reference_t<decltype(request.arg1)>>(params.arg1.unsignedShortValue);
+                request.arg2 = static_cast<std::remove_reference_t<decltype(request.arg2)>>(params.arg2.unsignedCharValue);
+
+                auto successFn = Callback<TestClusterClusterTestEnumsResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)testNullableOptionalRequestWithParams:(MTRTestClusterClusterTestNullableOptionalRequestParams * _Nullable)params
@@ -19377,36 +22386,52 @@ - (void)testNullableOptionalRequestWithParams:(MTRTestClusterClusterTestNullable
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRTestClusterClusterTestNullableOptionalResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::TestNullableOptionalRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            if (params != nil) {
-                if (params.arg1 != nil) {
-                    auto & definedValue_0 = request.arg1.Emplace();
-                    if (params.arg1 == nil) {
-                        definedValue_0.SetNull();
-                    } else {
-                        auto & nonNullValue_1 = definedValue_0.SetNonNull();
-                        nonNullValue_1 = params.arg1.unsignedCharValue;
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRTestClusterClusterTestNullableOptionalResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::TestNullableOptionalRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                if (params != nil) {
+                    if (params.arg1 != nil) {
+                        auto & definedValue_0 = request.arg1.Emplace();
+                        if (params.arg1 == nil) {
+                            definedValue_0.SetNull();
+                        } else {
+                            auto & nonNullValue_1 = definedValue_0.SetNonNull();
+                            nonNullValue_1 = params.arg1.unsignedCharValue;
+                        }
                     }
                 }
-            }
 
-            auto successFn = Callback<TestClusterClusterTestNullableOptionalResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn = Callback<TestClusterClusterTestNullableOptionalResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)testComplexNullableOptionalRequestWithParams:(MTRTestClusterClusterTestComplexNullableOptionalRequestParams *)params
@@ -19418,194 +22443,213 @@ - (void)testComplexNullableOptionalRequestWithParams:(MTRTestClusterClusterTestC
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRTestClusterClusterTestComplexNullableOptionalResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::TestComplexNullableOptionalRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            if (params.nullableInt == nil) {
-                request.nullableInt.SetNull();
-            } else {
-                auto & nonNullValue_0 = request.nullableInt.SetNonNull();
-                nonNullValue_0 = params.nullableInt.unsignedShortValue;
-            }
-            if (params.optionalInt != nil) {
-                auto & definedValue_0 = request.optionalInt.Emplace();
-                definedValue_0 = params.optionalInt.unsignedShortValue;
-            }
-            if (params.nullableOptionalInt != nil) {
-                auto & definedValue_0 = request.nullableOptionalInt.Emplace();
-                if (params.nullableOptionalInt == nil) {
-                    definedValue_0.SetNull();
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRTestClusterClusterTestComplexNullableOptionalResponseCallbackBridge(self.callbackQueue, baseDevice,
+            completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::TestComplexNullableOptionalRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                if (params.nullableInt == nil) {
+                    request.nullableInt.SetNull();
                 } else {
-                    auto & nonNullValue_1 = definedValue_0.SetNonNull();
-                    nonNullValue_1 = params.nullableOptionalInt.unsignedShortValue;
-                }
-            }
-            if (params.nullableString == nil) {
-                request.nullableString.SetNull();
-            } else {
-                auto & nonNullValue_0 = request.nullableString.SetNonNull();
-                nonNullValue_0 = [self asCharSpan:params.nullableString];
-            }
-            if (params.optionalString != nil) {
-                auto & definedValue_0 = request.optionalString.Emplace();
-                definedValue_0 = [self asCharSpan:params.optionalString];
-            }
-            if (params.nullableOptionalString != nil) {
-                auto & definedValue_0 = request.nullableOptionalString.Emplace();
-                if (params.nullableOptionalString == nil) {
-                    definedValue_0.SetNull();
+                    auto & nonNullValue_0 = request.nullableInt.SetNonNull();
+                    nonNullValue_0 = params.nullableInt.unsignedShortValue;
+                }
+                if (params.optionalInt != nil) {
+                    auto & definedValue_0 = request.optionalInt.Emplace();
+                    definedValue_0 = params.optionalInt.unsignedShortValue;
+                }
+                if (params.nullableOptionalInt != nil) {
+                    auto & definedValue_0 = request.nullableOptionalInt.Emplace();
+                    if (params.nullableOptionalInt == nil) {
+                        definedValue_0.SetNull();
+                    } else {
+                        auto & nonNullValue_1 = definedValue_0.SetNonNull();
+                        nonNullValue_1 = params.nullableOptionalInt.unsignedShortValue;
+                    }
+                }
+                if (params.nullableString == nil) {
+                    request.nullableString.SetNull();
                 } else {
-                    auto & nonNullValue_1 = definedValue_0.SetNonNull();
-                    nonNullValue_1 = [self asCharSpan:params.nullableOptionalString];
-                }
-            }
-            if (params.nullableStruct == nil) {
-                request.nullableStruct.SetNull();
-            } else {
-                auto & nonNullValue_0 = request.nullableStruct.SetNonNull();
-                nonNullValue_0.a = params.nullableStruct.a.unsignedCharValue;
-                nonNullValue_0.b = params.nullableStruct.b.boolValue;
-                nonNullValue_0.c
-                    = static_cast<std::remove_reference_t<decltype(nonNullValue_0.c)>>(params.nullableStruct.c.unsignedCharValue);
-                nonNullValue_0.d = [self asByteSpan:params.nullableStruct.d];
-                nonNullValue_0.e = [self asCharSpan:params.nullableStruct.e];
-                nonNullValue_0.f
-                    = static_cast<std::remove_reference_t<decltype(nonNullValue_0.f)>>(params.nullableStruct.f.unsignedCharValue);
-                nonNullValue_0.g = params.nullableStruct.g.floatValue;
-                nonNullValue_0.h = params.nullableStruct.h.doubleValue;
-            }
-            if (params.optionalStruct != nil) {
-                auto & definedValue_0 = request.optionalStruct.Emplace();
-                definedValue_0.a = params.optionalStruct.a.unsignedCharValue;
-                definedValue_0.b = params.optionalStruct.b.boolValue;
-                definedValue_0.c
-                    = static_cast<std::remove_reference_t<decltype(definedValue_0.c)>>(params.optionalStruct.c.unsignedCharValue);
-                definedValue_0.d = [self asByteSpan:params.optionalStruct.d];
-                definedValue_0.e = [self asCharSpan:params.optionalStruct.e];
-                definedValue_0.f
-                    = static_cast<std::remove_reference_t<decltype(definedValue_0.f)>>(params.optionalStruct.f.unsignedCharValue);
-                definedValue_0.g = params.optionalStruct.g.floatValue;
-                definedValue_0.h = params.optionalStruct.h.doubleValue;
-            }
-            if (params.nullableOptionalStruct != nil) {
-                auto & definedValue_0 = request.nullableOptionalStruct.Emplace();
-                if (params.nullableOptionalStruct == nil) {
-                    definedValue_0.SetNull();
+                    auto & nonNullValue_0 = request.nullableString.SetNonNull();
+                    nonNullValue_0 = [self asCharSpan:params.nullableString];
+                }
+                if (params.optionalString != nil) {
+                    auto & definedValue_0 = request.optionalString.Emplace();
+                    definedValue_0 = [self asCharSpan:params.optionalString];
+                }
+                if (params.nullableOptionalString != nil) {
+                    auto & definedValue_0 = request.nullableOptionalString.Emplace();
+                    if (params.nullableOptionalString == nil) {
+                        definedValue_0.SetNull();
+                    } else {
+                        auto & nonNullValue_1 = definedValue_0.SetNonNull();
+                        nonNullValue_1 = [self asCharSpan:params.nullableOptionalString];
+                    }
+                }
+                if (params.nullableStruct == nil) {
+                    request.nullableStruct.SetNull();
                 } else {
-                    auto & nonNullValue_1 = definedValue_0.SetNonNull();
-                    nonNullValue_1.a = params.nullableOptionalStruct.a.unsignedCharValue;
-                    nonNullValue_1.b = params.nullableOptionalStruct.b.boolValue;
-                    nonNullValue_1.c = static_cast<std::remove_reference_t<decltype(nonNullValue_1.c)>>(
-                        params.nullableOptionalStruct.c.unsignedCharValue);
-                    nonNullValue_1.d = [self asByteSpan:params.nullableOptionalStruct.d];
-                    nonNullValue_1.e = [self asCharSpan:params.nullableOptionalStruct.e];
-                    nonNullValue_1.f = static_cast<std::remove_reference_t<decltype(nonNullValue_1.f)>>(
-                        params.nullableOptionalStruct.f.unsignedCharValue);
-                    nonNullValue_1.g = params.nullableOptionalStruct.g.floatValue;
-                    nonNullValue_1.h = params.nullableOptionalStruct.h.doubleValue;
-                }
-            }
-            if (params.nullableList == nil) {
-                request.nullableList.SetNull();
-            } else {
-                auto & nonNullValue_0 = request.nullableList.SetNonNull();
-                {
-                    using ListType_1 = std::remove_reference_t<decltype(nonNullValue_0)>;
-                    using ListMemberType_1 = ListMemberTypeGetter<ListType_1>::Type;
-                    if (params.nullableList.count != 0) {
-                        auto * listHolder_1 = new ListHolder<ListMemberType_1>(params.nullableList.count);
-                        if (listHolder_1 == nullptr || listHolder_1->mList == nullptr) {
-                            return CHIP_ERROR_INVALID_ARGUMENT;
-                        }
-                        listFreer.add(listHolder_1);
-                        for (size_t i_1 = 0; i_1 < params.nullableList.count; ++i_1) {
-                            if (![params.nullableList[i_1] isKindOfClass:[NSNumber class]]) {
-                                // Wrong kind of value.
-                                return CHIP_ERROR_INVALID_ARGUMENT;
-                            }
-                            auto element_1 = (NSNumber *) params.nullableList[i_1];
-                            listHolder_1->mList[i_1] = static_cast<std::remove_reference_t<decltype(listHolder_1->mList[i_1])>>(
-                                element_1.unsignedCharValue);
-                        }
-                        nonNullValue_0 = ListType_1(listHolder_1->mList, params.nullableList.count);
+                    auto & nonNullValue_0 = request.nullableStruct.SetNonNull();
+                    nonNullValue_0.a = params.nullableStruct.a.unsignedCharValue;
+                    nonNullValue_0.b = params.nullableStruct.b.boolValue;
+                    nonNullValue_0.c = static_cast<std::remove_reference_t<decltype(nonNullValue_0.c)>>(
+                        params.nullableStruct.c.unsignedCharValue);
+                    nonNullValue_0.d = [self asByteSpan:params.nullableStruct.d];
+                    nonNullValue_0.e = [self asCharSpan:params.nullableStruct.e];
+                    nonNullValue_0.f = static_cast<std::remove_reference_t<decltype(nonNullValue_0.f)>>(
+                        params.nullableStruct.f.unsignedCharValue);
+                    nonNullValue_0.g = params.nullableStruct.g.floatValue;
+                    nonNullValue_0.h = params.nullableStruct.h.doubleValue;
+                }
+                if (params.optionalStruct != nil) {
+                    auto & definedValue_0 = request.optionalStruct.Emplace();
+                    definedValue_0.a = params.optionalStruct.a.unsignedCharValue;
+                    definedValue_0.b = params.optionalStruct.b.boolValue;
+                    definedValue_0.c = static_cast<std::remove_reference_t<decltype(definedValue_0.c)>>(
+                        params.optionalStruct.c.unsignedCharValue);
+                    definedValue_0.d = [self asByteSpan:params.optionalStruct.d];
+                    definedValue_0.e = [self asCharSpan:params.optionalStruct.e];
+                    definedValue_0.f = static_cast<std::remove_reference_t<decltype(definedValue_0.f)>>(
+                        params.optionalStruct.f.unsignedCharValue);
+                    definedValue_0.g = params.optionalStruct.g.floatValue;
+                    definedValue_0.h = params.optionalStruct.h.doubleValue;
+                }
+                if (params.nullableOptionalStruct != nil) {
+                    auto & definedValue_0 = request.nullableOptionalStruct.Emplace();
+                    if (params.nullableOptionalStruct == nil) {
+                        definedValue_0.SetNull();
                     } else {
-                        nonNullValue_0 = ListType_1();
+                        auto & nonNullValue_1 = definedValue_0.SetNonNull();
+                        nonNullValue_1.a = params.nullableOptionalStruct.a.unsignedCharValue;
+                        nonNullValue_1.b = params.nullableOptionalStruct.b.boolValue;
+                        nonNullValue_1.c = static_cast<std::remove_reference_t<decltype(nonNullValue_1.c)>>(
+                            params.nullableOptionalStruct.c.unsignedCharValue);
+                        nonNullValue_1.d = [self asByteSpan:params.nullableOptionalStruct.d];
+                        nonNullValue_1.e = [self asCharSpan:params.nullableOptionalStruct.e];
+                        nonNullValue_1.f = static_cast<std::remove_reference_t<decltype(nonNullValue_1.f)>>(
+                            params.nullableOptionalStruct.f.unsignedCharValue);
+                        nonNullValue_1.g = params.nullableOptionalStruct.g.floatValue;
+                        nonNullValue_1.h = params.nullableOptionalStruct.h.doubleValue;
                     }
                 }
-            }
-            if (params.optionalList != nil) {
-                auto & definedValue_0 = request.optionalList.Emplace();
-                {
-                    using ListType_1 = std::remove_reference_t<decltype(definedValue_0)>;
-                    using ListMemberType_1 = ListMemberTypeGetter<ListType_1>::Type;
-                    if (params.optionalList.count != 0) {
-                        auto * listHolder_1 = new ListHolder<ListMemberType_1>(params.optionalList.count);
-                        if (listHolder_1 == nullptr || listHolder_1->mList == nullptr) {
-                            return CHIP_ERROR_INVALID_ARGUMENT;
-                        }
-                        listFreer.add(listHolder_1);
-                        for (size_t i_1 = 0; i_1 < params.optionalList.count; ++i_1) {
-                            if (![params.optionalList[i_1] isKindOfClass:[NSNumber class]]) {
-                                // Wrong kind of value.
+                if (params.nullableList == nil) {
+                    request.nullableList.SetNull();
+                } else {
+                    auto & nonNullValue_0 = request.nullableList.SetNonNull();
+                    {
+                        using ListType_1 = std::remove_reference_t<decltype(nonNullValue_0)>;
+                        using ListMemberType_1 = ListMemberTypeGetter<ListType_1>::Type;
+                        if (params.nullableList.count != 0) {
+                            auto * listHolder_1 = new ListHolder<ListMemberType_1>(params.nullableList.count);
+                            if (listHolder_1 == nullptr || listHolder_1->mList == nullptr) {
                                 return CHIP_ERROR_INVALID_ARGUMENT;
                             }
-                            auto element_1 = (NSNumber *) params.optionalList[i_1];
-                            listHolder_1->mList[i_1] = static_cast<std::remove_reference_t<decltype(listHolder_1->mList[i_1])>>(
-                                element_1.unsignedCharValue);
+                            listFreer.add(listHolder_1);
+                            for (size_t i_1 = 0; i_1 < params.nullableList.count; ++i_1) {
+                                if (![params.nullableList[i_1] isKindOfClass:[NSNumber class]]) {
+                                    // Wrong kind of value.
+                                    return CHIP_ERROR_INVALID_ARGUMENT;
+                                }
+                                auto element_1 = (NSNumber *) params.nullableList[i_1];
+                                listHolder_1->mList[i_1] = static_cast<std::remove_reference_t<decltype(listHolder_1->mList[i_1])>>(
+                                    element_1.unsignedCharValue);
+                            }
+                            nonNullValue_0 = ListType_1(listHolder_1->mList, params.nullableList.count);
+                        } else {
+                            nonNullValue_0 = ListType_1();
                         }
-                        definedValue_0 = ListType_1(listHolder_1->mList, params.optionalList.count);
-                    } else {
-                        definedValue_0 = ListType_1();
                     }
                 }
-            }
-            if (params.nullableOptionalList != nil) {
-                auto & definedValue_0 = request.nullableOptionalList.Emplace();
-                if (params.nullableOptionalList == nil) {
-                    definedValue_0.SetNull();
-                } else {
-                    auto & nonNullValue_1 = definedValue_0.SetNonNull();
+                if (params.optionalList != nil) {
+                    auto & definedValue_0 = request.optionalList.Emplace();
                     {
-                        using ListType_2 = std::remove_reference_t<decltype(nonNullValue_1)>;
-                        using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
-                        if (params.nullableOptionalList.count != 0) {
-                            auto * listHolder_2 = new ListHolder<ListMemberType_2>(params.nullableOptionalList.count);
-                            if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
+                        using ListType_1 = std::remove_reference_t<decltype(definedValue_0)>;
+                        using ListMemberType_1 = ListMemberTypeGetter<ListType_1>::Type;
+                        if (params.optionalList.count != 0) {
+                            auto * listHolder_1 = new ListHolder<ListMemberType_1>(params.optionalList.count);
+                            if (listHolder_1 == nullptr || listHolder_1->mList == nullptr) {
                                 return CHIP_ERROR_INVALID_ARGUMENT;
                             }
-                            listFreer.add(listHolder_2);
-                            for (size_t i_2 = 0; i_2 < params.nullableOptionalList.count; ++i_2) {
-                                if (![params.nullableOptionalList[i_2] isKindOfClass:[NSNumber class]]) {
+                            listFreer.add(listHolder_1);
+                            for (size_t i_1 = 0; i_1 < params.optionalList.count; ++i_1) {
+                                if (![params.optionalList[i_1] isKindOfClass:[NSNumber class]]) {
                                     // Wrong kind of value.
                                     return CHIP_ERROR_INVALID_ARGUMENT;
                                 }
-                                auto element_2 = (NSNumber *) params.nullableOptionalList[i_2];
-                                listHolder_2->mList[i_2] = static_cast<std::remove_reference_t<decltype(listHolder_2->mList[i_2])>>(
-                                    element_2.unsignedCharValue);
+                                auto element_1 = (NSNumber *) params.optionalList[i_1];
+                                listHolder_1->mList[i_1] = static_cast<std::remove_reference_t<decltype(listHolder_1->mList[i_1])>>(
+                                    element_1.unsignedCharValue);
                             }
-                            nonNullValue_1 = ListType_2(listHolder_2->mList, params.nullableOptionalList.count);
+                            definedValue_0 = ListType_1(listHolder_1->mList, params.optionalList.count);
                         } else {
-                            nonNullValue_1 = ListType_2();
+                            definedValue_0 = ListType_1();
+                        }
+                    }
+                }
+                if (params.nullableOptionalList != nil) {
+                    auto & definedValue_0 = request.nullableOptionalList.Emplace();
+                    if (params.nullableOptionalList == nil) {
+                        definedValue_0.SetNull();
+                    } else {
+                        auto & nonNullValue_1 = definedValue_0.SetNonNull();
+                        {
+                            using ListType_2 = std::remove_reference_t<decltype(nonNullValue_1)>;
+                            using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
+                            if (params.nullableOptionalList.count != 0) {
+                                auto * listHolder_2 = new ListHolder<ListMemberType_2>(params.nullableOptionalList.count);
+                                if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
+                                    return CHIP_ERROR_INVALID_ARGUMENT;
+                                }
+                                listFreer.add(listHolder_2);
+                                for (size_t i_2 = 0; i_2 < params.nullableOptionalList.count; ++i_2) {
+                                    if (![params.nullableOptionalList[i_2] isKindOfClass:[NSNumber class]]) {
+                                        // Wrong kind of value.
+                                        return CHIP_ERROR_INVALID_ARGUMENT;
+                                    }
+                                    auto element_2 = (NSNumber *) params.nullableOptionalList[i_2];
+                                    listHolder_2->mList[i_2]
+                                        = static_cast<std::remove_reference_t<decltype(listHolder_2->mList[i_2])>>(
+                                            element_2.unsignedCharValue);
+                                }
+                                nonNullValue_1 = ListType_2(listHolder_2->mList, params.nullableOptionalList.count);
+                            } else {
+                                nonNullValue_1 = ListType_2();
+                            }
                         }
                     }
                 }
-            }
-
-            auto successFn = Callback<TestClusterClusterTestComplexNullableOptionalResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
 
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+                auto successFn
+                    = Callback<TestClusterClusterTestComplexNullableOptionalResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)simpleStructEchoRequestWithParams:(MTRTestClusterClusterSimpleStructEchoRequestParams *)params
@@ -19616,33 +22660,49 @@ - (void)simpleStructEchoRequestWithParams:(MTRTestClusterClusterSimpleStructEcho
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRTestClusterClusterSimpleStructResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::SimpleStructEchoRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.arg1.a = params.arg1.a.unsignedCharValue;
-            request.arg1.b = params.arg1.b.boolValue;
-            request.arg1.c = static_cast<std::remove_reference_t<decltype(request.arg1.c)>>(params.arg1.c.unsignedCharValue);
-            request.arg1.d = [self asByteSpan:params.arg1.d];
-            request.arg1.e = [self asCharSpan:params.arg1.e];
-            request.arg1.f = static_cast<std::remove_reference_t<decltype(request.arg1.f)>>(params.arg1.f.unsignedCharValue);
-            request.arg1.g = params.arg1.g.floatValue;
-            request.arg1.h = params.arg1.h.doubleValue;
-
-            auto successFn = Callback<TestClusterClusterSimpleStructResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRTestClusterClusterSimpleStructResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::SimpleStructEchoRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.arg1.a = params.arg1.a.unsignedCharValue;
+                request.arg1.b = params.arg1.b.boolValue;
+                request.arg1.c = static_cast<std::remove_reference_t<decltype(request.arg1.c)>>(params.arg1.c.unsignedCharValue);
+                request.arg1.d = [self asByteSpan:params.arg1.d];
+                request.arg1.e = [self asCharSpan:params.arg1.e];
+                request.arg1.f = static_cast<std::remove_reference_t<decltype(request.arg1.f)>>(params.arg1.f.unsignedCharValue);
+                request.arg1.g = params.arg1.g.floatValue;
+                request.arg1.h = params.arg1.h.doubleValue;
+
+                auto successFn = Callback<TestClusterClusterSimpleStructResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)timedInvokeRequestWithExpectedValues:(NSArray<NSDictionary<NSString *, id> *> *)expectedValues
@@ -19661,32 +22721,49 @@ - (void)timedInvokeRequestWithParams:(MTRTestClusterClusterTimedInvokeRequestPar
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::TimedInvokeRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            if (!timedInvokeTimeoutMs.HasValue()) {
-                timedInvokeTimeoutMs.SetValue(10000);
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::TimedInvokeRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                if (!timedInvokeTimeoutMs.HasValue()) {
+                    timedInvokeTimeoutMs.SetValue(10000);
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)testSimpleOptionalArgumentRequestWithParams:(MTRTestClusterClusterTestSimpleOptionalArgumentRequestParams * _Nullable)params
@@ -19696,35 +22773,52 @@ - (void)testSimpleOptionalArgumentRequestWithParams:(MTRTestClusterClusterTestSi
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRCommandSuccessCallbackBridge(
-        self.callbackQueue, baseDevice,
-        ^(id _Nullable value, NSError * _Nullable error) {
-            completionHandler(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::TestSimpleOptionalArgumentRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            if (params != nil) {
-                if (params.arg1 != nil) {
-                    auto & definedValue_0 = request.arg1.Emplace();
-                    definedValue_0 = params.arg1.boolValue;
-                }
-            }
-
-            auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRCommandSuccessCallbackBridge(
+            self.callbackQueue, baseDevice,
+            ^(id _Nullable value, NSError * _Nullable error) {
+                completionHandler(error);
+                [workItem endWork];
+            },
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::TestSimpleOptionalArgumentRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                if (params != nil) {
+                    if (params.arg1 != nil) {
+                        auto & definedValue_0 = request.arg1.Emplace();
+                        definedValue_0 = params.arg1.boolValue;
+                    }
+                }
+
+                auto successFn = Callback<CommandSuccessCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)testEmitTestEventRequestWithParams:(MTRTestClusterClusterTestEmitTestEventRequestParams *)params
@@ -19735,28 +22829,44 @@ - (void)testEmitTestEventRequestWithParams:(MTRTestClusterClusterTestEmitTestEve
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRTestClusterClusterTestEmitTestEventResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::TestEmitTestEventRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.arg1 = params.arg1.unsignedCharValue;
-            request.arg2 = static_cast<std::remove_reference_t<decltype(request.arg2)>>(params.arg2.unsignedCharValue);
-            request.arg3 = params.arg3.boolValue;
-
-            auto successFn = Callback<TestClusterClusterTestEmitTestEventResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRTestClusterClusterTestEmitTestEventResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::TestEmitTestEventRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.arg1 = params.arg1.unsignedCharValue;
+                request.arg2 = static_cast<std::remove_reference_t<decltype(request.arg2)>>(params.arg2.unsignedCharValue);
+                request.arg3 = params.arg3.boolValue;
+
+                auto successFn = Callback<TestClusterClusterTestEmitTestEventResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (void)testEmitTestFabricScopedEventRequestWithParams:(MTRTestClusterClusterTestEmitTestFabricScopedEventRequestParams *)params
@@ -19769,26 +22879,44 @@ - (void)testEmitTestFabricScopedEventRequestWithParams:(MTRTestClusterClusterTes
 {
     // Make a copy of params before we go async.
     params = [params copy];
-    MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID controller:self.device.deviceController];
-    new MTRTestClusterClusterTestEmitTestFabricScopedEventResponseCallbackBridge(self.callbackQueue, baseDevice, completionHandler,
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
-            chip::Optional<uint16_t> timedInvokeTimeoutMs;
-            ListFreer listFreer;
-            TestCluster::Commands::TestEmitTestFabricScopedEventRequest::Type request;
-            if (params != nil) {
-                if (params.timedInvokeTimeoutMs != nil) {
-                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
-                }
-            }
-            request.arg1 = params.arg1.unsignedCharValue;
-
-            auto successFn = Callback<TestClusterClusterTestEmitTestFabricScopedEventResponseCallbackType>::FromCancelable(success);
-            auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
-            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
-            return cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
-        });
-
-    [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs;
+    if (timedInvokeTimeoutMsParam) {
+        timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX));
+    }
+    MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.callbackQueue];
+    MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) {
+        MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID
+                                                                controller:self.device.deviceController];
+        new MTRTestClusterClusterTestEmitTestFabricScopedEventResponseCallbackBridge(self.callbackQueue, baseDevice,
+            completionHandler,
+            ^(ExchangeManager & exchangeManager, const SessionHandle & session, Cancelable * success, Cancelable * failure) {
+                chip::Optional<uint16_t> timedInvokeTimeoutMs;
+                ListFreer listFreer;
+                TestCluster::Commands::TestEmitTestFabricScopedEventRequest::Type request;
+                if (timedInvokeTimeoutMsParam != nil) {
+                    timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue);
+                }
+                request.arg1 = params.arg1.unsignedCharValue;
+
+                auto successFn
+                    = Callback<TestClusterClusterTestEmitTestFabricScopedEventResponseCallbackType>::FromCancelable(success);
+                auto failureFn = Callback<DefaultFailureCallbackType>::FromCancelable(failure);
+                chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
+                return cppCluster.InvokeCommand(
+                    request, successFn->mContext, successFn->mCall, failureFn->mCall, timedInvokeTimeoutMs);
+            });
+    };
+    workItem.readyHandler = readyHandler;
+    [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem];
+
+    if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) {
+        expectedValues = nil;
+    } else {
+        expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX));
+    }
+    if (expectedValues) {
+        [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs];
+    }
 }
 
 - (NSDictionary<NSString *, id> *)readAttributeBooleanWithParams:(MTRReadParams * _Nullable)params
diff --git a/src/lib/dnssd/Discovery_ImplPlatform.cpp b/src/lib/dnssd/Discovery_ImplPlatform.cpp
index a5feca89881854..6d4b775f16f675 100644
--- a/src/lib/dnssd/Discovery_ImplPlatform.cpp
+++ b/src/lib/dnssd/Discovery_ImplPlatform.cpp
@@ -641,6 +641,12 @@ CHIP_ERROR DiscoveryImplPlatform::StopDiscovery()
     return mResolverProxy.StopDiscovery();
 }
 
+CHIP_ERROR DiscoveryImplPlatform::ReconfirmRecord(const char * hostname, Inet::IPAddress address, Inet::InterfaceId interfaceId)
+{
+    ReturnErrorOnFailure(InitImpl());
+    return mResolverProxy.ReconfirmRecord(hostname, address, interfaceId);
+}
+
 DiscoveryImplPlatform & DiscoveryImplPlatform::GetInstance()
 {
     return sManager;
@@ -750,5 +756,10 @@ CHIP_ERROR ResolverProxy::StopDiscovery()
     return err;
 }
 
+CHIP_ERROR ResolverProxy::ReconfirmRecord(const char * hostname, Inet::IPAddress address, Inet::InterfaceId interfaceId)
+{
+    return ChipDnssdReconfirmRecord(hostname, address, interfaceId);
+}
+
 } // namespace Dnssd
 } // namespace chip
diff --git a/src/lib/dnssd/Discovery_ImplPlatform.h b/src/lib/dnssd/Discovery_ImplPlatform.h
index dcee5bc0974f7c..0723dbf0fedf0c 100644
--- a/src/lib/dnssd/Discovery_ImplPlatform.h
+++ b/src/lib/dnssd/Discovery_ImplPlatform.h
@@ -58,6 +58,7 @@ class DiscoveryImplPlatform : public ServiceAdvertiser, public Resolver
     CHIP_ERROR DiscoverCommissionableNodes(DiscoveryFilter filter = DiscoveryFilter()) override;
     CHIP_ERROR DiscoverCommissioners(DiscoveryFilter filter = DiscoveryFilter()) override;
     CHIP_ERROR StopDiscovery() override;
+    CHIP_ERROR ReconfirmRecord(const char * hostname, Inet::IPAddress address, Inet::InterfaceId interfaceId) override;
 
     static DiscoveryImplPlatform & GetInstance();
 
diff --git a/src/lib/dnssd/Resolver.h b/src/lib/dnssd/Resolver.h
index dddbed07625ebe..efba2ba931a2ff 100644
--- a/src/lib/dnssd/Resolver.h
+++ b/src/lib/dnssd/Resolver.h
@@ -398,6 +398,12 @@ class Resolver
      */
     virtual CHIP_ERROR StopDiscovery() = 0;
 
+    /**
+     * Verify the validity of an address that appears to be out of date (for example
+     * because establishing a connection to it has failed).
+     */
+    virtual CHIP_ERROR ReconfirmRecord(const char * hostname, Inet::IPAddress address, Inet::InterfaceId interfaceId) = 0;
+
     /**
      * Provides the system-wide implementation of the service resolver
      */
diff --git a/src/lib/dnssd/ResolverProxy.h b/src/lib/dnssd/ResolverProxy.h
index 36ada23a486dcf..b8bf3fbacb7082 100644
--- a/src/lib/dnssd/ResolverProxy.h
+++ b/src/lib/dnssd/ResolverProxy.h
@@ -153,6 +153,7 @@ class ResolverProxy : public Resolver
     CHIP_ERROR DiscoverCommissionableNodes(DiscoveryFilter filter = DiscoveryFilter()) override;
     CHIP_ERROR DiscoverCommissioners(DiscoveryFilter filter = DiscoveryFilter()) override;
     CHIP_ERROR StopDiscovery() override;
+    CHIP_ERROR ReconfirmRecord(const char * hostname, Inet::IPAddress address, Inet::InterfaceId interfaceId) override;
 
 private:
     ResolverDelegateProxy * mDelegate                            = nullptr;
diff --git a/src/lib/dnssd/Resolver_ImplMinimalMdns.cpp b/src/lib/dnssd/Resolver_ImplMinimalMdns.cpp
index cf168d78139c9d..7e9c44e4d8072f 100644
--- a/src/lib/dnssd/Resolver_ImplMinimalMdns.cpp
+++ b/src/lib/dnssd/Resolver_ImplMinimalMdns.cpp
@@ -282,6 +282,7 @@ class MinMdnsResolver : public Resolver, public MdnsPacketDelegate
     CHIP_ERROR DiscoverCommissionableNodes(DiscoveryFilter filter = DiscoveryFilter()) override;
     CHIP_ERROR DiscoverCommissioners(DiscoveryFilter filter = DiscoveryFilter()) override;
     CHIP_ERROR StopDiscovery() override;
+    CHIP_ERROR ReconfirmRecord(const char * hostname, Inet::IPAddress address, Inet::InterfaceId interfaceId) override;
 
 private:
     OperationalResolveDelegate * mOperationalDelegate     = nullptr;
@@ -639,6 +640,11 @@ CHIP_ERROR MinMdnsResolver::StopDiscovery()
     return mActiveResolves.CompleteAllBrowses();
 }
 
+CHIP_ERROR MinMdnsResolver::ReconfirmRecord(const char * hostname, Inet::IPAddress address, Inet::InterfaceId interfaceId)
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+
 CHIP_ERROR MinMdnsResolver::BrowseNodes(DiscoveryType type, DiscoveryFilter filter)
 {
     mActiveResolves.MarkPending(filter, type);
@@ -723,5 +729,10 @@ CHIP_ERROR ResolverProxy::StopDiscovery()
     return CHIP_ERROR_NOT_IMPLEMENTED;
 }
 
+CHIP_ERROR ResolverProxy::ReconfirmRecord(const char * hostname, Inet::IPAddress address, Inet::InterfaceId interfaceId)
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+
 } // namespace Dnssd
 } // namespace chip
diff --git a/src/lib/dnssd/Resolver_ImplNone.cpp b/src/lib/dnssd/Resolver_ImplNone.cpp
index 5fe429f8a62444..c4d4cc0f6dce84 100644
--- a/src/lib/dnssd/Resolver_ImplNone.cpp
+++ b/src/lib/dnssd/Resolver_ImplNone.cpp
@@ -43,6 +43,10 @@ class NoneResolver : public Resolver
     }
     CHIP_ERROR DiscoverCommissioners(DiscoveryFilter filter = DiscoveryFilter()) override { return CHIP_ERROR_NOT_IMPLEMENTED; }
     CHIP_ERROR StopDiscovery() override { return CHIP_ERROR_NOT_IMPLEMENTED; }
+    CHIP_ERROR ReconfirmRecord(const char * hostname, Inet::IPAddress address, Inet::InterfaceId interfaceId) override
+    {
+        return CHIP_ERROR_NOT_IMPLEMENTED;
+    }
 };
 
 NoneResolver gResolver;
@@ -79,5 +83,10 @@ CHIP_ERROR ResolverProxy::StopDiscovery()
     return CHIP_ERROR_NOT_IMPLEMENTED;
 }
 
+CHIP_ERROR ResolverProxy::ReconfirmRecord(const char * hostname, Inet::IPAddress address, Inet::InterfaceId interfaceId)
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+
 } // namespace Dnssd
 } // namespace chip
diff --git a/src/lib/dnssd/platform/Dnssd.h b/src/lib/dnssd/platform/Dnssd.h
index 1bce362b400782..188ff52f980ee9 100644
--- a/src/lib/dnssd/platform/Dnssd.h
+++ b/src/lib/dnssd/platform/Dnssd.h
@@ -245,5 +245,15 @@ CHIP_ERROR ChipDnssdStopBrowse(intptr_t browseIdentifier);
 CHIP_ERROR ChipDnssdResolve(DnssdService * browseResult, chip::Inet::InterfaceId interface, DnssdResolveCallback callback,
                             void * context);
 
+/**
+ * This function asks the mdns daemon to asynchronously reconfirm an address that appears to be out of date.
+ *
+ * @param[in] hostname      The hostname the address belongs to.
+ * @param[in] address       The address to reconfirm.
+ * @param[in] interfaceId   The interfaceId of the address.
+ *
+ */
+CHIP_ERROR ChipDnssdReconfirmRecord(const char * hostname, chip::Inet::IPAddress address, chip::Inet::InterfaceId interface);
+
 } // namespace Dnssd
 } // namespace chip
diff --git a/src/lib/support/Pool.cpp b/src/lib/support/Pool.cpp
index e7f5f576a59b59..c32b46be45e819 100644
--- a/src/lib/support/Pool.cpp
+++ b/src/lib/support/Pool.cpp
@@ -22,6 +22,33 @@
 
 namespace chip {
 
+#if CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+
+bool HeapObjectPoolExitHandling::sIgnoringLeaksOnExit   = false;
+bool HeapObjectPoolExitHandling::sExitHandlerRegistered = false;
+
+void HeapObjectPoolExitHandling::IgnoreLeaksOnExit()
+{
+    if (sExitHandlerRegistered)
+    {
+        return;
+    }
+
+    int ret = atexit(ExitHandler);
+    if (ret != 0)
+    {
+        ChipLogError(Controller, "IgnoreLeaksOnExit: atexit failed: %d\n", ret);
+    }
+    sExitHandlerRegistered = true;
+}
+
+void HeapObjectPoolExitHandling::ExitHandler()
+{
+    sIgnoringLeaksOnExit = true;
+}
+
+#endif // CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
+
 namespace internal {
 
 StaticAllocatorBitmap::StaticAllocatorBitmap(void * storage, std::atomic<tBitChunkType> * usage, size_t capacity,
diff --git a/src/lib/support/Pool.h b/src/lib/support/Pool.h
index 54914c7d91d141..72d1a1842b0e36 100644
--- a/src/lib/support/Pool.h
+++ b/src/lib/support/Pool.h
@@ -291,13 +291,30 @@ class BitMapObjectPool : public internal::StaticAllocatorBitmap, public internal
 
 #if CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
 
+class HeapObjectPoolExitHandling
+{
+public:
+    // If IgnoreLeaksOnExit is called, some time after all static initializers have
+    // run, HeapObjectPool will not assert that everything in it has been
+    // released if its destructor runs under exit() (i.e. when the application
+    // is quitting anyway).
+    static void IgnoreLeaksOnExit();
+
+protected:
+    static bool sIgnoringLeaksOnExit;
+
+private:
+    static void ExitHandler();
+    static bool sExitHandlerRegistered;
+};
+
 /**
  * A class template used for allocating objects from the heap.
  *
  *  @tparam     T   type to be allocated.
  */
 template <class T>
-class HeapObjectPool : public internal::Statistics, public internal::PoolCommon<T>
+class HeapObjectPool : public internal::Statistics, public internal::PoolCommon<T>, public HeapObjectPoolExitHandling
 {
 public:
     HeapObjectPool() {}
@@ -314,8 +331,11 @@ class HeapObjectPool : public internal::Statistics, public internal::PoolCommon<
         // Free all remaining objects so that ASAN can catch specific use-after-free cases.
         ReleaseAll();
 #else  // __SANITIZE_ADDRESS__
-       // Verify that no live objects remain, to prevent potential use-after-free.
-        VerifyOrDie(Allocated() == 0);
+        if (!sIgnoringLeaksOnExit)
+        {
+            // Verify that no live objects remain, to prevent potential use-after-free.
+            VerifyOrDie(Allocated() == 0);
+        }
 #endif // __SANITIZE_ADDRESS__
     }
 
diff --git a/src/lwip/efr32/lwipopts-rs911x.h b/src/lwip/efr32/lwipopts-rs911x.h
index 839636b3ae7f0a..66fbf69f2c8a5b 100644
--- a/src/lwip/efr32/lwipopts-rs911x.h
+++ b/src/lwip/efr32/lwipopts-rs911x.h
@@ -50,7 +50,9 @@
 #define LWIP_DHCP_AUTOIP_COOP (0)
 #define LWIP_SOCKET_SET_ERRNO 0
 #define IP_REASS_MAX_PBUFS 0
-#define IP_REASSEMBLY 0
+#define IP_REASSEMBLY 1
+#define IP_FRAG 1
+#define IP_OPTIONS_ALLOWED 1
 #define MEMP_NUM_REASSDATA 0
 #define LWIP_SO_RCVTIMEO 0
 #define SO_REUSE (1)
@@ -77,32 +79,32 @@
 
 #define MEMP_NUM_NETCONN (0)
 
-#ifndef LWIP_IPV4
-#define LWIP_IPV4 1
-#endif
-#ifndef LWIP_IPV6
-#define LWIP_IPV6 1
-#endif
 #ifndef LWIP_ARP
-#define LWIP_ARP (1)
-#endif
-#define LWIP_DNS (0)
+#define LWIP_ARP (LWIP_IPV4)
+#endif /* LWIP_ARP */
+#ifndef LWIP_DNS
+#define LWIP_DNS (LWIP_IPV4)
+#endif /* LWIP_DNS */
 #ifndef LWIP_ICMP
-#define LWIP_ICMP (1)
-#endif
+#define LWIP_ICMP (LWIP_IPV4)
+#endif /* LWIP_ICMP */
 #ifndef LWIP_IGMP
-#define LWIP_IGMP (1)
-#endif
+#define LWIP_IGMP (LWIP_IPV4)
+#endif /* LWIP_IGMP */
 #ifndef LWIP_DHCP
-#define LWIP_DHCP (1)
-#endif
-#define LWIP_IPV6_REASS (0)
+#define LWIP_DHCP (LWIP_IPV4)
+#endif /* LWIP_DHCP */
+
+#define LWIP_ETHERNET (LWIP_IPV6) // Required for IPV6 only mode
+#define LWIP_IPV6_MLD (LWIP_IPV6)
+#define LWIP_ICMP6 (LWIP_IPV6)
+#define LWIP_IPV6_REASS (LWIP_IPV6)
+#define LWIP_IPV6_FRAG (LWIP_IPV6)
 #define LWIP_IPV6_DHCP6 0
-#define LWIP_IPV6_AUTOCONFIG (1)
+#define LWIP_IPV6_AUTOCONFIG (LWIP_IPV6)
 #define LWIP_IPV6_DUP_DETECT_ATTEMPTS 1
-#define LWIP_IPV6_ROUTER_SUPPORT 1
-#define LWIP_ND6_LISTEN_RA 1
-
+#define LWIP_IPV6_ROUTER_SUPPORT (LWIP_IPV6)
+#define LWIP_ND6_LISTEN_RA (LWIP_IPV6_ND)
 #define LWIP_ND6_NUM_NEIGHBORS (2)
 #define LWIP_ND6_NUM_DESTINATIONS (3)
 #define LWIP_ND6_NUM_PREFIXES (2)
@@ -111,7 +113,7 @@
 #define LWIP_ND6_MAX_UNICAST_SOLICIT (2)
 #define LWIP_ND6_MAX_NEIGHBOR_ADVERTISEMENT (3)
 #define LWIP_ND6_TCP_REACHABILITY_HINTS (0)
-#define LWIP_ND6_ALLOW_RA_UPDATES 1
+#define LWIP_ND6_ALLOW_RA_UPDATES (LWIP_IPV6_ND)
 
 #if defined(EFR32MG21)
 #define MEMP_SEPARATE_POOLS (1)
@@ -121,7 +123,7 @@
 #define PBUF_POOL_BUFSIZE (1280)
 #define PBUF_CUSTOM_POOL_IDX_START (MEMP_PBUF_POOL_SMALL)
 #define PBUF_CUSTOM_POOL_IDX_END (MEMP_PBUF_POOL_LARGE)
-#else
+#else /* !(EFR32MG21) */
 #define MEMP_SEPARATE_POOLS (1)
 #define LWIP_PBUF_FROM_CUSTOM_POOLS (0)
 #define MEMP_USE_CUSTOM_POOLS (0)
@@ -129,7 +131,7 @@
 #define PBUF_POOL_BUFSIZE (1280) // IPv6 path MTU
 #define PBUF_CUSTOM_POOL_IDX_START (MEMP_PBUF_POOL_SMALL)
 #define PBUF_CUSTOM_POOL_IDX_END (MEMP_PBUF_POOL_LARGE)
-#endif
+#endif /* EFR32MG21 */
 
 #define TCP_MSS (1152)
 #define TCP_SND_BUF (2 * TCP_MSS)
@@ -141,9 +143,9 @@
 
 #if defined(EFR32MG21)
 #define TCPIP_THREAD_STACKSIZE (1536)
-#else
+#else /* !(EFR32MG21) */
 #define TCPIP_THREAD_STACKSIZE (2048)
-#endif
+#endif /* EFR32MG21 */
 
 #define TCPIP_THREAD_PRIO (2)
 
@@ -151,10 +153,8 @@
 
 #define LWIP_IPV6_NUM_ADDRESSES 5
 
-#ifndef LWIP_IPV6_ND
-#define LWIP_IPV6_ND 1
-#endif
-#define LWIP_ND6_QUEUEING 1
+#define LWIP_IPV6_ND (LWIP_IPV6)
+#define LWIP_ND6_QUEUEING (LWIP_IPV6)
 #define LWIP_NUM_ND6_QUEUE 3
 
 #define LWIP_MULTICAST_PING 0
@@ -185,6 +185,7 @@
 #define IP6_DEBUG (LWIP_DBG_OFF)
 #define RAW_DEBUG (LWIP_DBG_OFF)
 #define ICMP_DEBUG (LWIP_DBG_OFF)
+#define ICMP6_DEBUG (LWIP_DBG_OFF)
 #define UDP_DEBUG (LWIP_DBG_OFF)
 #define TCP_DEBUG (LWIP_DBG_OFF)
 #define TCP_INPUT_DEBUG (LWIP_DBG_OFF)
@@ -196,9 +197,8 @@
 #define TCP_QLEN_DEBUG (LWIP_DBG_OFF)
 #define TCP_RST_DEBUG (LWIP_DBG_OFF)
 #define PPP_DEBUG (LWIP_DBG_OFF)
-#endif
+#endif /* LWIP_DEBUG */
 
 #define LWIP_DBG_TYPES_ON                                                                                                          \
     (LWIP_DBG_ON | LWIP_DBG_TRACE) /* (LWIP_DBG_ON|LWIP_DBG_TRACE|LWIP_DBG_STATE|LWIP_DBG_FRESH|LWIP_DBG_HALT) */
-
-#endif /* __LWIPOPTS_H__ */
+#endif                             /* __LWIPOPTS_H__ */
diff --git a/src/lwip/efr32/lwipopts-wf200.h b/src/lwip/efr32/lwipopts-wf200.h
index 0811154e84c1c1..b1dc32fb1a53b2 100644
--- a/src/lwip/efr32/lwipopts-wf200.h
+++ b/src/lwip/efr32/lwipopts-wf200.h
@@ -50,7 +50,9 @@
 #define LWIP_DHCP_AUTOIP_COOP (0)
 #define LWIP_SOCKET_SET_ERRNO 0
 #define IP_REASS_MAX_PBUFS 0
-#define IP_REASSEMBLY 0
+#define IP_REASSEMBLY 1
+#define IP_FRAG 1
+#define IP_OPTIONS_ALLOWED 1
 #define MEMP_NUM_REASSDATA 0
 #define LWIP_SO_RCVTIMEO 0
 #define SO_REUSE (1)
@@ -77,32 +79,32 @@
 
 #define MEMP_NUM_NETCONN (0)
 
-#ifndef LWIP_IPV4
-#define LWIP_IPV4 0
-#endif
-#ifndef LWIP_IPV6
-#define LWIP_IPV6 1
-#endif
 #ifndef LWIP_ARP
-#define LWIP_ARP (0)
-#endif
-#define LWIP_DNS (0)
+#define LWIP_ARP (LWIP_IPV4)
+#endif /* LWIP_ARP */
+#ifndef LWIP_DNS
+#define LWIP_DNS (LWIP_IPV4)
+#endif /* LWIP_DNS */
 #ifndef LWIP_ICMP
-#define LWIP_ICMP (1)
-#endif
+#define LWIP_ICMP (LWIP_IPV4)
+#endif /* LWIP_ICMP */
 #ifndef LWIP_IGMP
-#define LWIP_IGMP (0)
-#endif
+#define LWIP_IGMP (LWIP_IPV4)
+#endif /* LWIP_IGMP */
 #ifndef LWIP_DHCP
-#define LWIP_DHCP (0)
-#endif
-#define LWIP_IPV6_REASS (0)
+#define LWIP_DHCP (LWIP_IPV4)
+#endif /* LWIP_DHCP */
+
+#define LWIP_ETHERNET (LWIP_IPV6) // Required for IPV6 only mode
+#define LWIP_IPV6_MLD (LWIP_IPV6)
+#define LWIP_ICMP6 (LWIP_IPV6)
+#define LWIP_IPV6_REASS (LWIP_IPV6)
+#define LWIP_IPV6_FRAG (LWIP_IPV6)
 #define LWIP_IPV6_DHCP6 0
-#define LWIP_IPV6_AUTOCONFIG (1)
+#define LWIP_IPV6_AUTOCONFIG (LWIP_IPV6)
 #define LWIP_IPV6_DUP_DETECT_ATTEMPTS 1
-#define LWIP_IPV6_ROUTER_SUPPORT 1
-#define LWIP_ND6_LISTEN_RA 1
-
+#define LWIP_IPV6_ROUTER_SUPPORT (LWIP_IPV6)
+#define LWIP_ND6_LISTEN_RA (LWIP_IPV6_ND)
 #define LWIP_ND6_NUM_NEIGHBORS (2)
 #define LWIP_ND6_NUM_DESTINATIONS (3)
 #define LWIP_ND6_NUM_PREFIXES (2)
@@ -111,7 +113,7 @@
 #define LWIP_ND6_MAX_UNICAST_SOLICIT (2)
 #define LWIP_ND6_MAX_NEIGHBOR_ADVERTISEMENT (3)
 #define LWIP_ND6_TCP_REACHABILITY_HINTS (0)
-#define LWIP_ND6_ALLOW_RA_UPDATES 1
+#define LWIP_ND6_ALLOW_RA_UPDATES (LWIP_IPV6_ND)
 
 #if defined(EFR32MG21)
 #define MEMP_SEPARATE_POOLS (1)
@@ -121,15 +123,15 @@
 #define PBUF_POOL_BUFSIZE (1280)
 #define PBUF_CUSTOM_POOL_IDX_START (MEMP_PBUF_POOL_SMALL)
 #define PBUF_CUSTOM_POOL_IDX_END (MEMP_PBUF_POOL_LARGE)
-#else
+#else /* !(EFR32MG21) */
 #define MEMP_SEPARATE_POOLS (1)
 #define LWIP_PBUF_FROM_CUSTOM_POOLS (0)
 #define MEMP_USE_CUSTOM_POOLS (0)
 #define PBUF_POOL_SIZE (16)
-#define PBUF_POOL_BUFSIZE (1280)
+#define PBUF_POOL_BUFSIZE (1280) // IPv6 path MTU
 #define PBUF_CUSTOM_POOL_IDX_START (MEMP_PBUF_POOL_SMALL)
 #define PBUF_CUSTOM_POOL_IDX_END (MEMP_PBUF_POOL_LARGE)
-#endif
+#endif /* EFR32MG21 */
 
 #define TCP_MSS (1152)
 #define TCP_SND_BUF (2 * TCP_MSS)
@@ -141,9 +143,9 @@
 
 #if defined(EFR32MG21)
 #define TCPIP_THREAD_STACKSIZE (1536)
-#else
+#else /* !(EFR32MG21) */
 #define TCPIP_THREAD_STACKSIZE (2048)
-#endif
+#endif /* EFR32MG21 */
 
 #define TCPIP_THREAD_PRIO (2)
 
@@ -151,10 +153,8 @@
 
 #define LWIP_IPV6_NUM_ADDRESSES 5
 
-#ifndef LWIP_IPV6_ND
-#define LWIP_IPV6_ND 0
-#endif
-#define LWIP_ND6_QUEUEING 1
+#define LWIP_IPV6_ND (LWIP_IPV6)
+#define LWIP_ND6_QUEUEING (LWIP_IPV6)
 #define LWIP_NUM_ND6_QUEUE 3
 
 #define LWIP_MULTICAST_PING 0
@@ -185,6 +185,7 @@
 #define IP6_DEBUG (LWIP_DBG_OFF)
 #define RAW_DEBUG (LWIP_DBG_OFF)
 #define ICMP_DEBUG (LWIP_DBG_OFF)
+#define ICMP6_DEBUG (LWIP_DBG_OFF)
 #define UDP_DEBUG (LWIP_DBG_OFF)
 #define TCP_DEBUG (LWIP_DBG_OFF)
 #define TCP_INPUT_DEBUG (LWIP_DBG_OFF)
@@ -196,9 +197,8 @@
 #define TCP_QLEN_DEBUG (LWIP_DBG_OFF)
 #define TCP_RST_DEBUG (LWIP_DBG_OFF)
 #define PPP_DEBUG (LWIP_DBG_OFF)
-#endif
+#endif /* LWIP_DEBUG */
 
 #define LWIP_DBG_TYPES_ON                                                                                                          \
     (LWIP_DBG_ON | LWIP_DBG_TRACE) /* (LWIP_DBG_ON|LWIP_DBG_TRACE|LWIP_DBG_STATE|LWIP_DBG_FRESH|LWIP_DBG_HALT) */
-
-#endif /* __LWIPOPTS_H__ */
+#endif                             /* __LWIPOPTS_H__ */
diff --git a/src/messaging/ReliableMessageProtocolConfig.cpp b/src/messaging/ReliableMessageProtocolConfig.cpp
index 00abf5376dd049..a0ff8ab64ceec1 100644
--- a/src/messaging/ReliableMessageProtocolConfig.cpp
+++ b/src/messaging/ReliableMessageProtocolConfig.cpp
@@ -51,7 +51,7 @@ void ClearLocalMRPConfigOverride()
 ReliableMessageProtocolConfig GetDefaultMRPConfig()
 {
     // Default MRP intervals are defined in spec <2.11.3. Parameters and Constants>
-    static constexpr const System::Clock::Milliseconds32 idleRetransTimeout   = 4000_ms32;
+    static constexpr const System::Clock::Milliseconds32 idleRetransTimeout   = 300_ms32;
     static constexpr const System::Clock::Milliseconds32 activeRetransTimeout = 300_ms32;
     return ReliableMessageProtocolConfig(idleRetransTimeout, activeRetransTimeout);
 }
diff --git a/src/messaging/ReliableMessageProtocolConfig.h b/src/messaging/ReliableMessageProtocolConfig.h
index eaefaa3ecfe8e1..b705d05beec621 100644
--- a/src/messaging/ReliableMessageProtocolConfig.h
+++ b/src/messaging/ReliableMessageProtocolConfig.h
@@ -39,7 +39,7 @@ namespace chip {
  *    subsequent failures in milliseconds.
  *
  *  This is the default value, that might be adjusted by end device depending on its
- *  needs (e.g. sleeping period) using Service Discovery TXT record CRA key.
+ *  needs (e.g. sleeping period) using Service Discovery TXT record SAI key.
  *
  */
 #ifndef CHIP_CONFIG_MRP_LOCAL_ACTIVE_RETRY_INTERVAL
@@ -54,10 +54,10 @@ namespace chip {
  *    failure in milliseconds.
  *
  * This is the default value, that might be adjusted by end device depending on its
- * needs (e.g. sleeping period) using Service Discovery TXT record CRI key.
+ * needs (e.g. sleeping period) using Service Discovery TXT record SII key.
  */
 #ifndef CHIP_CONFIG_MRP_LOCAL_IDLE_RETRY_INTERVAL
-#define CHIP_CONFIG_MRP_LOCAL_IDLE_RETRY_INTERVAL (5000_ms32)
+#define CHIP_CONFIG_MRP_LOCAL_IDLE_RETRY_INTERVAL (300_ms32)
 #endif // CHIP_CONFIG_MRP_LOCAL_IDLE_RETRY_INTERVAL
 
 /**
diff --git a/src/platform/Darwin/DnssdImpl.cpp b/src/platform/Darwin/DnssdImpl.cpp
index a955941a8c633c..8d08b4c3f3daca 100644
--- a/src/platform/Darwin/DnssdImpl.cpp
+++ b/src/platform/Darwin/DnssdImpl.cpp
@@ -36,10 +36,11 @@ constexpr const char * kLocalDot    = "local.";
 constexpr const char * kProtocolTcp = "._tcp";
 constexpr const char * kProtocolUdp = "._udp";
 
-constexpr DNSServiceFlags kRegisterFlags    = kDNSServiceFlagsNoAutoRename;
-constexpr DNSServiceFlags kBrowseFlags      = 0;
-constexpr DNSServiceFlags kGetAddrInfoFlags = kDNSServiceFlagsTimeout | kDNSServiceFlagsShareConnection;
-constexpr DNSServiceFlags kResolveFlags     = kDNSServiceFlagsShareConnection;
+constexpr DNSServiceFlags kRegisterFlags        = kDNSServiceFlagsNoAutoRename;
+constexpr DNSServiceFlags kBrowseFlags          = 0;
+constexpr DNSServiceFlags kGetAddrInfoFlags     = kDNSServiceFlagsTimeout | kDNSServiceFlagsShareConnection;
+constexpr DNSServiceFlags kResolveFlags         = kDNSServiceFlagsShareConnection;
+constexpr DNSServiceFlags kReconfirmRecordFlags = 0;
 
 bool IsSupportedProtocol(DnssdServiceProtocol protocol)
 {
@@ -446,5 +447,49 @@ CHIP_ERROR ChipDnssdResolve(DnssdService * service, chip::Inet::InterfaceId inte
     return Resolve(context, callback, interfaceId, service->mAddressType, regtype.c_str(), service->mName);
 }
 
+CHIP_ERROR ChipDnssdReconfirmRecord(const char * hostname, chip::Inet::IPAddress address, chip::Inet::InterfaceId interface)
+{
+    VerifyOrReturnError(hostname != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
+
+    auto interfaceId = interface.GetPlatformInterface();
+    auto rrclass     = kDNSServiceClass_IN;
+    auto fullname    = GetHostNameWithDomain(hostname);
+
+    uint16_t rrtype;
+    uint16_t rdlen;
+    const void * rdata;
+
+    in6_addr ipv6;
+#if INET_CONFIG_ENABLE_IPV4
+    in_addr ipv4;
+#endif // INET_CONFIG_ENABLE_IPV4
+
+    if (address.IsIPv6())
+    {
+        ipv6   = address.ToIPv6();
+        rrtype = kDNSServiceType_AAAA;
+        rdlen  = static_cast<uint16_t>(sizeof(in6_addr));
+        rdata  = &ipv6;
+    }
+#if INET_CONFIG_ENABLE_IPV4
+    else if (address.IsIPv4())
+    {
+        ipv4   = address.ToIPv4();
+        rrtype = kDNSServiceType_A;
+        rdlen  = static_cast<uint16_t>(sizeof(in_addr));
+        rdata  = &ipv4;
+    }
+#endif // INET_CONFIG_ENABLE_IPV4
+    else
+    {
+        return CHIP_ERROR_INVALID_ARGUMENT;
+    }
+
+    auto error = DNSServiceReconfirmRecord(kReconfirmRecordFlags, interfaceId, fullname.c_str(), rrtype, rrclass, rdlen, rdata);
+    LogOnFailure(__func__, error);
+
+    return Error::ToChipError(error);
+}
+
 } // namespace Dnssd
 } // namespace chip
diff --git a/src/platform/EFR32/wifi/dhcp_client.cpp b/src/platform/EFR32/wifi/dhcp_client.cpp
index b78e21f84411f2..f3e8c5597ad922 100644
--- a/src/platform/EFR32/wifi/dhcp_client.cpp
+++ b/src/platform/EFR32/wifi/dhcp_client.cpp
@@ -15,6 +15,8 @@
  *    limitations under the License.
  */
 
+#if LWIP_IPV4 && LWIP_DHCP
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -143,3 +145,5 @@ uint8_t dhcpclient_poll(void * arg)
     }
     return dhcp_state;
 }
+
+#endif /* LWIP_IPV4 && LWIP_DHCP */
diff --git a/src/platform/EFR32/wifi/dhcp_client.h b/src/platform/EFR32/wifi/dhcp_client.h
index 5937f6a29d86d3..3040f7112fb954 100644
--- a/src/platform/EFR32/wifi/dhcp_client.h
+++ b/src/platform/EFR32/wifi/dhcp_client.h
@@ -15,6 +15,8 @@
  *    limitations under the License.
  */
 
+#if LWIP_IPV4 && LWIP_DHCP
+
 #pragma once
 #ifdef __cplusplus
 extern "C" {
@@ -39,3 +41,5 @@ uint8_t dhcpclient_poll(void * arg);
 #ifdef __cplusplus
 }
 #endif
+
+#endif /* LWIP_IPV4 && LWIP_DHCP */
diff --git a/src/platform/EFR32/wifi/ethernetif.cpp b/src/platform/EFR32/wifi/ethernetif.cpp
index 09fbf421235fdd..4ac27d69f194e4 100644
--- a/src/platform/EFR32/wifi/ethernetif.cpp
+++ b/src/platform/EFR32/wifi/ethernetif.cpp
@@ -431,8 +431,12 @@ err_t sta_ethernetif_init(struct netif * netif)
     netif->name[0] = STATION_NETIF0;
     netif->name[1] = STATION_NETIF1;
 
-    netif->output     = etharp_output;
+#if LWIP_IPV4 && LWIP_ARP
+    netif->output = etharp_output;
+#endif /* #if LWIP_IPV4 && LWIP_ARP */
+#if LWIP_IPV6 && LWIP_ETHERNET
     netif->output_ip6 = ethip6_output;
+#endif /* LWIP_IPV6 && LWIP_ETHERNET */
     netif->linkoutput = low_level_output;
 
     /* initialize the hardware */
diff --git a/src/platform/EFR32/wifi/lwip_netif.cpp b/src/platform/EFR32/wifi/lwip_netif.cpp
index cd3a34292cf85a..e19cf97a7cefd2 100644
--- a/src/platform/EFR32/wifi/lwip_netif.cpp
+++ b/src/platform/EFR32/wifi/lwip_netif.cpp
@@ -58,6 +58,7 @@ static void netif_config(struct netif * sta_if, struct netif * ap_if)
 {
     if (sta_if != NULL)
     {
+#if LWIP_IPV4
         ip_addr_t sta_ipaddr;
         ip_addr_t sta_netmask;
         ip_addr_t sta_gw;
@@ -66,10 +67,14 @@ static void netif_config(struct netif * sta_if, struct netif * ap_if)
         ip_addr_set_zero_ip4(&sta_ipaddr);
         ip_addr_set_zero_ip4(&sta_netmask);
         ip_addr_set_zero_ip4(&sta_gw);
+#endif /* LWIP_IPV4 */
 
         /* Add station interfaces */
-        netif_add(sta_if, (const ip4_addr_t *) &sta_ipaddr, (const ip4_addr_t *) &sta_netmask, (const ip4_addr_t *) &sta_gw, NULL,
-                  &sta_ethernetif_init, &tcpip_input);
+        netif_add(sta_if,
+#if LWIP_IPV4
+                  (const ip4_addr_t *) &sta_ipaddr, (const ip4_addr_t *) &sta_netmask, (const ip4_addr_t *) &sta_gw,
+#endif /* LWIP_IPV4 */
+                  NULL, &sta_ethernetif_init, &tcpip_input);
 
         /* Registers the default network interface */
         netif_set_default(sta_if);
@@ -87,7 +92,9 @@ void wfx_lwip_set_sta_link_up(void)
 {
     netifapi_netif_set_up(&sta_netif);
     netifapi_netif_set_link_up(&sta_netif);
+#if LWIP_IPV4 && LWIP_DHCP
     dhcpclient_set_link_state(LINK_UP);
+#endif /* LWIP_IPV4 && LWIP_DHCP */
     /*
      * Enable IPV6
      */
@@ -107,7 +114,9 @@ void wfx_lwip_set_sta_link_up(void)
  *****************************************************************************/
 void wfx_lwip_set_sta_link_down(void)
 {
+#if LWIP_IPV4 && LWIP_DHCP
     dhcpclient_set_link_state(LINK_DOWN);
+#endif /* LWIP_IPV4 && LWIP_DHCP */
     netifapi_netif_set_link_down(&sta_netif);
     netifapi_netif_set_down(&sta_netif);
 }
diff --git a/src/platform/EFR32/wifi/wfx_host_events.h b/src/platform/EFR32/wifi/wfx_host_events.h
index 6a1e367d29cad0..be64a8a65594b4 100644
--- a/src/platform/EFR32/wifi/wfx_host_events.h
+++ b/src/platform/EFR32/wifi/wfx_host_events.h
@@ -258,7 +258,9 @@ sl_status_t wfx_connect_to_ap(void);
 void wfx_setup_ip6_link_local(sl_wfx_interface_t);
 bool wfx_is_sta_connected(void);
 sl_status_t wfx_sta_discon(void);
+#if CHIP_DEVICE_CONFIG_ENABLE_IPV4
 bool wfx_have_ipv4_addr(sl_wfx_interface_t);
+#endif /* CHIP_DEVICE_CONFIG_ENABLE_IPV4 */
 bool wfx_have_ipv6_addr(sl_wfx_interface_t);
 wifi_mode_t wfx_get_wifi_mode(void);
 bool wfx_start_scan(char * ssid, void (*scan_cb)(wfx_wifi_scan_result_t *)); /* true returned if successfuly started */
@@ -276,9 +278,13 @@ void wfx_lwip_set_sta_link_up(void);
 void wfx_lwip_set_sta_link_down(void);
 void wfx_lwip_start(void);
 struct netif * wfx_get_netif(sl_wfx_interface_t interface);
+#if CHIP_DEVICE_CONFIG_ENABLE_IPV4
 void wfx_dhcp_got_ipv4(uint32_t);
+#endif /* CHIP_DEVICE_CONFIG_ENABLE_IPV4 */
 bool wfx_hw_ready(void);
+#if CHIP_DEVICE_CONFIG_ENABLE_IPV4
 void wfx_ip_changed_notify(int got_ip);
+#endif /* CHIP_DEVICE_CONFIG_ENABLE_IPV4 */
 void wfx_ipv6_notify(int got_ip);
 
 #ifdef RS911X_WIFI
diff --git a/src/platform/ESP32/DnssdImpl.cpp b/src/platform/ESP32/DnssdImpl.cpp
index 342ce11a8c3015..4f592b8666885b 100644
--- a/src/platform/ESP32/DnssdImpl.cpp
+++ b/src/platform/ESP32/DnssdImpl.cpp
@@ -511,5 +511,10 @@ CHIP_ERROR ChipDnssdResolve(DnssdService * service, chip::Inet::InterfaceId inte
     return error;
 }
 
+CHIP_ERROR ChipDnssdReconfirmRecord(const char * hostname, chip::Inet::IPAddress address, chip::Inet::InterfaceId interface)
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+
 } // namespace Dnssd
 } // namespace chip
diff --git a/src/platform/Linux/DnssdImpl.cpp b/src/platform/Linux/DnssdImpl.cpp
index 758fa1569dd8a9..c813177729ebcb 100644
--- a/src/platform/Linux/DnssdImpl.cpp
+++ b/src/platform/Linux/DnssdImpl.cpp
@@ -872,5 +872,10 @@ CHIP_ERROR ChipDnssdResolve(DnssdService * browseResult, chip::Inet::InterfaceId
                                             browseResult->mAddressType, Inet::IPAddressType::kAny, interface, callback, context);
 }
 
+CHIP_ERROR ChipDnssdReconfirmRecord(const char * hostname, chip::Inet::IPAddress address, chip::Inet::InterfaceId interface)
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+
 } // namespace Dnssd
 } // namespace chip
diff --git a/src/platform/OpenThread/DnssdImpl.cpp b/src/platform/OpenThread/DnssdImpl.cpp
index 654b7cab5054b4..5800afa202198b 100644
--- a/src/platform/OpenThread/DnssdImpl.cpp
+++ b/src/platform/OpenThread/DnssdImpl.cpp
@@ -122,5 +122,10 @@ CHIP_ERROR ChipDnssdResolve(DnssdService * browseResult, Inet::InterfaceId inter
 #endif // CHIP_DEVICE_CONFIG_ENABLE_THREAD_SRP_CLIENT && CHIP_DEVICE_CONFIG_ENABLE_THREAD_DNS_CLIENT
 }
 
+CHIP_ERROR ChipDnssdReconfirmRecord(const char * hostname, chip::Inet::IPAddress address, chip::Inet::InterfaceId interface)
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+
 } // namespace Dnssd
 } // namespace chip
diff --git a/src/platform/Tizen/DnssdImpl.cpp b/src/platform/Tizen/DnssdImpl.cpp
index 1d10c71574e1f5..30593f07c2408c 100644
--- a/src/platform/Tizen/DnssdImpl.cpp
+++ b/src/platform/Tizen/DnssdImpl.cpp
@@ -823,5 +823,10 @@ CHIP_ERROR ChipDnssdResolve(DnssdService * browseResult, chip::Inet::InterfaceId
     return DnssdTizen::GetInstance().Resolve(*browseResult, interface, callback, context);
 }
 
+CHIP_ERROR ChipDnssdReconfirmRecord(const char * hostname, chip::Inet::IPAddress address, chip::Inet::InterfaceId interface)
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+
 } // namespace Dnssd
 } // namespace chip
diff --git a/src/platform/android/DnssdImpl.cpp b/src/platform/android/DnssdImpl.cpp
index 7ed8e771d82546..36546689e1fc3e 100644
--- a/src/platform/android/DnssdImpl.cpp
+++ b/src/platform/android/DnssdImpl.cpp
@@ -214,6 +214,11 @@ CHIP_ERROR ChipDnssdResolve(DnssdService * service, Inet::InterfaceId interface,
     return CHIP_NO_ERROR;
 }
 
+CHIP_ERROR ChipDnssdReconfirmRecord(const char * hostname, chip::Inet::IPAddress address, chip::Inet::InterfaceId interface)
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+
 // Implemention of Java-specific functions
 
 void InitializeWithObjects(jobject resolverObject, jobject browserObject, jobject mdnsCallbackObject)
diff --git a/src/platform/bouffalolab/BL602/DnssdImpl.cpp b/src/platform/bouffalolab/BL602/DnssdImpl.cpp
index 143d19eb5cb374..e2e5779d0c5bf7 100644
--- a/src/platform/bouffalolab/BL602/DnssdImpl.cpp
+++ b/src/platform/bouffalolab/BL602/DnssdImpl.cpp
@@ -313,5 +313,10 @@ CHIP_ERROR ChipDnssdResolve(DnssdService * /*service*/, chip::Inet::InterfaceId
     return CHIP_ERROR_NOT_IMPLEMENTED;
 }
 
+CHIP_ERROR ChipDnssdReconfirmRecord(const char * hostname, chip::Inet::IPAddress address, chip::Inet::InterfaceId interface)
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+
 } // namespace Dnssd
 } // namespace chip
diff --git a/src/platform/fake/DnssdImpl.cpp b/src/platform/fake/DnssdImpl.cpp
index 7fcc82c7bc8931..fbce5984f7f059 100644
--- a/src/platform/fake/DnssdImpl.cpp
+++ b/src/platform/fake/DnssdImpl.cpp
@@ -132,6 +132,11 @@ CHIP_ERROR ChipDnssdResolve(DnssdService * browseResult, chip::Inet::InterfaceId
     return CHIP_ERROR_NOT_IMPLEMENTED;
 }
 
+CHIP_ERROR ChipDnssdReconfirmRecord(const char * hostname, chip::Inet::IPAddress address, chip::Inet::InterfaceId interface)
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+
 void GetMdnsTimeout(timeval & timeout) {}
 void HandleMdnsTimeout() {}
 
diff --git a/src/platform/mt793x/DnssdImpl.cpp b/src/platform/mt793x/DnssdImpl.cpp
index a88eeac1c62463..e61bbeeefc4ee0 100644
--- a/src/platform/mt793x/DnssdImpl.cpp
+++ b/src/platform/mt793x/DnssdImpl.cpp
@@ -273,5 +273,10 @@ CHIP_ERROR ChipDnssdResolve(DnssdService * service, chip::Inet::InterfaceId inte
     return error;
 }
 
+CHIP_ERROR ChipDnssdReconfirmRecord(const char * hostname, chip::Inet::IPAddress address, chip::Inet::InterfaceId interface)
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+
 } // namespace Dnssd
 } // namespace chip
diff --git a/src/platform/webos/DnssdImpl.cpp b/src/platform/webos/DnssdImpl.cpp
index 043d6bb01c7020..97ce39bad012aa 100644
--- a/src/platform/webos/DnssdImpl.cpp
+++ b/src/platform/webos/DnssdImpl.cpp
@@ -869,5 +869,10 @@ CHIP_ERROR ChipDnssdResolve(DnssdService * browseResult, chip::Inet::InterfaceId
                                             browseResult->mAddressType, Inet::IPAddressType::kAny, interface, callback, context);
 }
 
+CHIP_ERROR ChipDnssdReconfirmRecord(const char * hostname, chip::Inet::IPAddress address, chip::Inet::InterfaceId interface)
+{
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+
 } // namespace Dnssd
 } // namespace chip
diff --git a/src/protocols/secure_channel/CASESession.cpp b/src/protocols/secure_channel/CASESession.cpp
index 209d8b29101b79..0f2d2c2316c7af 100644
--- a/src/protocols/secure_channel/CASESession.cpp
+++ b/src/protocols/secure_channel/CASESession.cpp
@@ -116,10 +116,15 @@ using HKDF_sha_crypto = HKDF_shaHSM;
 using HKDF_sha_crypto = HKDF_sha;
 #endif
 
-// Wait at most 30 seconds for the response from the peer.
-// This timeout value assumes the underlying transport is reliable.
-// The session establishment fails if the response is not received within timeout window.
-static constexpr ExchangeContext::Timeout kSigma_Response_Timeout = System::Clock::Seconds16(30);
+// Amounts of time to allow for server-side processing of messages.
+//
+// These timeout values only allow for the server-side processing and assume that any transport-specific
+// latency will be added to them.
+//
+// The session establishment fails if the response is not received within the resulting timeout window,
+// which accounts for both transport latency and the server-side latency.
+static constexpr ExchangeContext::Timeout kExpectedLowProcessingTime  = System::Clock::Seconds16(2);
+static constexpr ExchangeContext::Timeout kExpectedHighProcessingTime = System::Clock::Seconds16(30);
 
 CASESession::~CASESession()
 {
@@ -260,7 +265,7 @@ CHIP_ERROR CASESession::EstablishSession(SessionManager & sessionManager, Fabric
     mSessionResumptionStorage = sessionResumptionStorage;
     mLocalMRPConfig           = mrpLocalConfig;
 
-    mExchangeCtxt->SetResponseTimeout(kSigma_Response_Timeout + mExchangeCtxt->GetSessionHandle()->GetAckTimeout());
+    mExchangeCtxt->UseSuggestedResponseTimeout(kExpectedLowProcessingTime);
     mPeerNodeId  = peerScopedNodeId.GetNodeId();
     mLocalNodeId = fabricInfo->GetNodeId();
 
@@ -1723,8 +1728,8 @@ CHIP_ERROR CASESession::ValidateReceivedMessage(ExchangeContext * ec, const Payl
     else
     {
         mExchangeCtxt = ec;
-        mExchangeCtxt->SetResponseTimeout(kSigma_Response_Timeout + mExchangeCtxt->GetSessionHandle()->GetAckTimeout());
     }
+    mExchangeCtxt->UseSuggestedResponseTimeout(kExpectedHighProcessingTime);
 
     VerifyOrReturnError(!msg.IsNull(), CHIP_ERROR_INVALID_ARGUMENT);
     return CHIP_NO_ERROR;
diff --git a/src/protocols/secure_channel/PASESession.cpp b/src/protocols/secure_channel/PASESession.cpp
index 67b462fa860838..1537a33a42baed 100644
--- a/src/protocols/secure_channel/PASESession.cpp
+++ b/src/protocols/secure_channel/PASESession.cpp
@@ -57,10 +57,15 @@ const char * kSpake2pContext        = "CHIP PAKE V1 Commissioning";
 const char * kSpake2pI2RSessionInfo = "Commissioning I2R Key";
 const char * kSpake2pR2ISessionInfo = "Commissioning R2I Key";
 
-// Wait at most 30 seconds for the response from the peer.
-// This timeout value assumes the underlying transport is reliable.
-// The session establishment fails if the response is not received with in timeout window.
-static constexpr ExchangeContext::Timeout kSpake2p_Response_Timeout = System::Clock::Seconds16(30);
+// Amounts of time to allow for server-side processing of messages.
+//
+// These timeout values only allow for the server-side processing and assume that any transport-specific
+// latency will be added to them.
+//
+// The session establishment fails if the response is not received within the resulting timeout window,
+// which accounts for both transport latency and the server-side latency.
+static constexpr ExchangeContext::Timeout kExpectedLowProcessingTime  = System::Clock::Seconds16(2);
+static constexpr ExchangeContext::Timeout kExpectedHighProcessingTime = System::Clock::Seconds16(30);
 
 PASESession::~PASESession()
 {
@@ -216,7 +221,7 @@ CHIP_ERROR PASESession::Pair(SessionManager & sessionManager, uint32_t peerSetUp
     // When commissioning starts, the peer is assumed to be active.
     mExchangeCtxt->GetSessionHandle()->AsUnauthenticatedSession()->MarkActiveRx();
 
-    mExchangeCtxt->SetResponseTimeout(kSpake2p_Response_Timeout + mExchangeCtxt->GetSessionHandle()->GetAckTimeout());
+    mExchangeCtxt->UseSuggestedResponseTimeout(kExpectedLowProcessingTime);
 
     mLocalMRPConfig = mrpLocalConfig;
 
@@ -787,8 +792,8 @@ CHIP_ERROR PASESession::ValidateReceivedMessage(ExchangeContext * exchange, cons
     else
     {
         mExchangeCtxt = exchange;
-        mExchangeCtxt->SetResponseTimeout(kSpake2p_Response_Timeout + mExchangeCtxt->GetSessionHandle()->GetAckTimeout());
     }
+    mExchangeCtxt->UseSuggestedResponseTimeout(kExpectedHighProcessingTime);
 
     VerifyOrReturnError(!msg.IsNull(), CHIP_ERROR_INVALID_ARGUMENT);
     VerifyOrReturnError((mNextExpectedMsg.HasValue() && payloadHeader.HasMessageType(mNextExpectedMsg.Value())) ||
diff --git a/src/setup_payload/java/src/chip/setuppayload/SetupPayloadParser.java b/src/setup_payload/java/src/chip/setuppayload/SetupPayloadParser.java
index 89601ac18a3cdc..1f035253c27d4a 100644
--- a/src/setup_payload/java/src/chip/setuppayload/SetupPayloadParser.java
+++ b/src/setup_payload/java/src/chip/setuppayload/SetupPayloadParser.java
@@ -1,8 +1,13 @@
 package chip.setuppayload;
 
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
 /** Parser for scanned QR code or manual entry code. */
 public class SetupPayloadParser {
 
+  private static final Logger LOGGER = Logger.getLogger(SetupPayloadParser.class.getSimpleName());
+
   /**
    * Returns {@link SetupPayload} parsed from the QR code string. If an invalid element is included
    * in the QRCode Parse result, SetupPayloadException occurs. Refer to {@link SetupPayload} for the
@@ -69,7 +74,11 @@ private native SetupPayload fetchPayloadFromManualEntryCode(
       throws InvalidEntryCodeFormatException, SetupPayloadException;
 
   static {
-    System.loadLibrary("SetupPayloadParser");
+    try {
+      System.loadLibrary("SetupPayloadParser");
+    } catch (UnsatisfiedLinkError e) {
+      LOGGER.log(Level.SEVERE, "Cannot load library.", e);
+    }
   }
 
   public static class UnrecognizedQrCodeException extends Exception {
diff --git a/third_party/silabs/matter_support b/third_party/silabs/matter_support
index 58b1a4fd07291a..f033c5099804fa 160000
--- a/third_party/silabs/matter_support
+++ b/third_party/silabs/matter_support
@@ -1 +1 @@
-Subproject commit 58b1a4fd07291aecf710b5de268d34682c3768c2
+Subproject commit f033c5099804fae5003c70f5f6de21a5e39464f2